".format(repr((self.state_label_before, self.state_label_after, self.evaluated, self.rolled_back, self.execution_id, self.parent_header)))
32 |
33 |
34 | class CellJournal:
35 |
36 | def __init__(self, kernel):
37 | self.log = kernel.log # TODO
38 | self.history = []
39 |
40 | def add(self, state_label_before, state_label_after, evaluated, rolled_back, execution_id, parent_header):
41 | record = CellRecord(state_label_before, state_label_after, evaluated, rolled_back, execution_id, parent_header)
42 | self.history.append(record)
43 | return record
44 |
45 | def find_by_execution_id(self, execution_id):
46 | result = list(filter(lambda r: r.execution_id == execution_id, self.history))
47 | if len(result) == 1:
48 | return result[0]
49 | else:
50 | return None
51 |
52 | def find_rolled_back_transitively(self, state_label_before):
53 | return list(filter(lambda r: int(r.state_label_before) > int(state_label_before) and not r.rolled_back, self.history))
54 |
55 |
56 | def shutdown_on_coqtop_error(function):
57 | def wrapper(self, *args, **kwargs):
58 | try:
59 | return function(self, *args, **kwargs)
60 | except CoqtopError:
61 | self.log.exception("CoqtopError has occured. Scheduling shutdown.")
62 | from tornado import ioloop
63 | loop = ioloop.IOLoop.current()
64 | loop.add_timeout(time.time() + 0.1, loop.stop)
65 | raise
66 |
67 | return wrapper
68 |
69 |
70 | class CoqKernel(Kernel):
71 | implementation = 'coq'
72 | implementation_version = __version__
73 | language = 'coq'
74 |
75 | @property
76 | def language_info(self):
77 | return {
78 | 'name': 'coq',
79 | 'mimetype': 'text/x-coq',
80 | 'file_extension': '.v',
81 | 'version': self.language_version
82 | }
83 |
84 | @property
85 | def banner(self):
86 | return self._coqtop.banner
87 |
88 | @property
89 | def language_version(self):
90 | return ".".join(map(str, self._coqtop.version))
91 |
92 |
93 | coqtop_executable = Unicode().tag(config=True)
94 | coqtop_args = Unicode().tag(config=True)
95 |
96 |
97 | @shutdown_on_coqtop_error
98 | def __init__(self, **kwargs):
99 | Kernel.__init__(self, **kwargs)
100 | self._coqtop = Coqtop(self, self.coqtop_executable, self.coqtop_args)
101 | self._journal = CellJournal(self)
102 | self._renderer = Renderer()
103 | self._kernel_comms = []
104 | for msg_type in ['comm_open', 'comm_msg', 'comm_close']:
105 | self.shell_handlers[msg_type] = getattr(self, msg_type)
106 |
107 | def do_execute(self, code, silent, store_history=True, user_expressions=None, allow_stdin=False):
108 | try:
109 | self.log.info("Processing 'execute_request', code: \n{}\n".format(repr(code)))
110 |
111 | if "coq_kernel_roll_back_cell" in self._parent_header["content"]:
112 | self._roll_back(self._parent_header["content"]["coq_kernel_roll_back_cell"])
113 |
114 | if code.strip("\n\r\t ") != "":
115 | state_label_before = self._coqtop.tip
116 | (evaluated, outputs) = shutdown_on_coqtop_error(lambda self: self._coqtop.eval(code))(self)
117 | state_label_after = self._coqtop.tip
118 | execution_id = self._parent_header["msg_id"]
119 |
120 | record = self._journal.add(state_label_before, state_label_after, evaluated, False, execution_id, self._parent_header)
121 |
122 | if not silent:
123 | self.log.info("Sending 'execute_result', cell record:\n{}\n".format(repr(record)))
124 | self._send_execute_result(outputs, execution_id, evaluated, False, state_label_after)
125 |
126 | return self._build_ok_content(state_label_before)
127 | else:
128 | self.log.info("code is empty - skipping evaluation and sending results.")
129 | return self._build_ok_content(self._coqtop.tip)
130 |
131 | except Exception as e:
132 | self.log.exception("Error during evaluating code: \n'{}'\n".format(repr(code)))
133 | return self._build_error_content(*sys.exc_info())
134 |
135 | def comm_open(self, stream, ident, msg):
136 | content = msg["content"]
137 | if content["target_name"] == CELL_COMM_TARGET_NAME:
138 | self._init_kernel_comm(content["comm_id"])
139 | else:
140 | self.log.error("Unexpected comm_open, msg: {}".format(repr(msg)))
141 |
142 | def comm_close(self, stream, ident, msg):
143 | self._kernel_comms.remove(msg["content"]["comm_id"])
144 | self.log.info("Kernel comm closed, msg: {}".format(repr(msg)))
145 |
146 | @shutdown_on_coqtop_error
147 | def comm_msg(self, stream, ident, msg):
148 | content = msg["content"]
149 | if content["comm_id"] in self._kernel_comms:
150 | if content["data"]["comm_msg_type"] == "roll_back":
151 | self._roll_back(msg["content"]["data"]["execution_id"])
152 | else:
153 | self.log.error("Unexpected comm_msg, msg: {}".format(repr(msg)))
154 | else:
155 | self.log.info("Unexpected (possibly leftover) comm_msg, msg: {}, opened comms: {}".format(repr(msg)), repr(self._kernel_comms))
156 |
157 | def _init_kernel_comm(self, comm_id):
158 | self._send_kernel_comm_opened_comm_msg(comm_id, self._journal.history)
159 | self._kernel_comms.append(comm_id)
160 | self.log.info("Kernel comm opened, comm_id: {}".format(comm_id))
161 |
162 | def _roll_back(self, execution_id):
163 | self.log.info("roll back, execution_id: {}".format(execution_id))
164 | cell_record = self._journal.find_by_execution_id(execution_id)
165 |
166 | if cell_record is not None and cell_record.evaluated and not cell_record.rolled_back:
167 | self._coqtop.roll_back_to(cell_record.state_label_before)
168 |
169 | for record in [cell_record] + self._journal.find_rolled_back_transitively(cell_record.state_label_before):
170 | # mark cell as rolled back
171 | record.rolled_back= True
172 |
173 | # update content of rolled back cell
174 | self._send_roll_back_update_display_data(record.parent_header, record.execution_id, record.evaluated, record.rolled_back)
175 |
176 | # update cell state via kernel comms
177 | for comm_id in self._kernel_comms:
178 | self._send_cell_state_comm_msg(comm_id, record.execution_id, record.evaluated, record.rolled_back)
179 |
180 | else:
181 | self.log.info("Unexpected (possibly leftover) roll back request for execution_id: {}".format(execution_id))
182 |
183 | def _build_ok_content(self, state_label_before):
184 | return {
185 | 'status': 'ok',
186 | 'execution_count': int(state_label_before),
187 | 'payload': [],
188 | 'user_expressions': {},
189 | }
190 |
191 | def _build_error_content(self, ex_type, ex, tb):
192 | return {
193 | 'status': 'error',
194 | 'ename' : ex_type.__name__,
195 | 'evalue' : repr(ex),
196 | 'traceback' : traceback.format_list(traceback.extract_tb(tb))
197 | }
198 |
199 | def _build_display_data_content(self, text, html, execution_id, evaluated, rolled_back):
200 | return {
201 | 'data': {
202 | 'text/plain': text,
203 | 'text/html': html
204 | },
205 | 'metadata': {
206 | 'coq_kernel_execution_id': execution_id,
207 | 'coq_kernel_evaluated': evaluated,
208 | 'coq_kernel_rolled_back': rolled_back
209 | },
210 | 'transient': { 'display_id': execution_id }
211 | }
212 |
213 | def _send_kernel_comm_opened_comm_msg(self, comm_id, history):
214 | content = {
215 | "comm_id": comm_id,
216 | "data": {
217 | "comm_msg_type": "kernel_comm_opened",
218 | "history": [
219 | {
220 | "execution_id": record.execution_id,
221 | "evaluated": record.evaluated,
222 | "rolled_back": record.rolled_back
223 | }
224 | for record in history
225 | ]
226 | }
227 | }
228 | self.session.send(self.iopub_socket, "comm_msg", content, None, None, None, None, None, None)
229 |
230 | def _send_cell_state_comm_msg(self, comm_id, execution_id, evaluated, rolled_back):
231 | content = {
232 | "comm_id": comm_id,
233 | "data": {
234 | "comm_msg_type": "cell_state",
235 | "execution_id": execution_id,
236 | "evaluated": evaluated,
237 | "rolled_back": rolled_back
238 | }
239 | }
240 | self.session.send(self.iopub_socket, "comm_msg", content, None, None, None, None, None, None)
241 |
242 | def _send_roll_back_update_display_data(self, parent_header, execution_id, evaluated, rolled_back):
243 | content = self._build_display_data_content(TEXT_ROLLED_BACK_STATUS_MESSAGE, HTML_ROLLED_BACK_STATUS_MESSAGE, execution_id, evaluated, rolled_back)
244 | self.session.send(self.iopub_socket, "update_display_data", content, parent_header, None, None, None, None, None)
245 |
246 | def _send_execute_result(self, outputs, execution_id, evaluated, rolled_back, state_label_after):
247 | text = self._renderer.render_text_result(outputs)
248 | html = self._renderer.render_html_result(outputs, execution_id, evaluated)
249 | content = self._build_display_data_content(text, html, execution_id, evaluated, rolled_back)
250 | content['execution_count'] = int(state_label_after)
251 | self.send_response(self.iopub_socket, 'execute_result', content)
252 |
--------------------------------------------------------------------------------
/coq_jupyter/renderer.py:
--------------------------------------------------------------------------------
1 | from __future__ import unicode_literals
2 |
3 | import os
4 |
5 |
6 | HTML_SUCCESS_STATUS_MESSAGE = """
7 |
8 |
9 | Cell evaluated.
10 |
11 | """
12 |
13 | HTML_ERROR_STATUS_MESSAGE = """
14 |
15 |
16 | Error while evaluating cell. Cell rolled back.
17 |
18 | """
19 |
20 | HTML_ROLLED_BACK_STATUS_MESSAGE = """
21 |
22 |
23 | Cell rolled back.
24 |
25 | """
26 |
27 | HTML_ROLLED_BACK_STATUS_MESSAGE_HIDDEN = """
28 |
29 |
30 | Cell rolled back.
31 |
32 | """
33 |
34 | TEXT_ROLLED_BACK_STATUS_MESSAGE = "Cell rolled back."
35 |
36 | HTML_OUTPUT_TEMPLATE = """
37 |
40 | """
41 |
42 | HTML_ROLL_BACK_CONTROLS = """
43 |
44 |
48 |
49 |
50 |
51 | Auto rollback
52 |
53 |