def _insert_import(self, name, module): lineno = self.autoimport.find_insertion_line(self.source) current = lisp.point() lisp.goto_line(lineno) newimport = 'from %s import %s\n' % (module, name) lisp.insert(newimport) lisp.goto_char(current + len(newimport))
def occurrences_goto(): if lisp.line_number_at_pos() < 1: lisp.forward_line(1 - lisp.line_number_at_pos()) lisp.end_of_line() end = lisp.point() lisp.beginning_of_line() line = lisp.buffer_substring_no_properties(lisp.point(), end) tokens = line.split() semicolon_tokens = line.split(":") project_root = lisp.rope_get_project_root() if tokens and semicolon_tokens: # Mark this line with an arrow lisp(''' (remove-overlays (point-min) (point-max)) (overlay-put (make-overlay (line-beginning-position) (line-end-position)) 'before-string (propertize "A" 'display '(left-fringe right-triangle))) ''') filename = project_root + "/" + semicolon_tokens[0] offset = int(tokens[-1]) resource = _interface._get_resource(filename) LispUtils().find_file(resource.real_path, other=True) lisp.goto_char(offset + 1)
def get_line_offset(): """Return number of characters cursor is offset from margin. """ user_pos = lisp.point() lisp.beginning_of_line() line_start = lisp.point() lisp.goto_char(user_pos) return user_pos - line_start
def convert(): remember_where = lisp.point() block_begin, block_end, content = get_block_content("\n\n", "\n\n") # alttaki listeye dokunulmamasi istenen kelimeler tek ogeli # tuple olarak yazilir, ("kelime",) gibi. eger degisim isteniyorsa # ("kelime","degisim") olarak bir tuple eklenir. r_list = [("verisi", ), ("Calculus", ), ("AIC", ), ("estimator", ), (" ise", ), ("kontur", ), ("ODE", ), ("Oklit", u'Öklit'), ("karekok", u'karekök'), ("kismi", u'kısmi'), ("integral", ), ("oldugu", u'olduğu'), ("parcaci", u"parçacı"), ("acilimi", u'açılımı'), ("acilim", u'açılım'), ("acisini", u'açısını'), ("acisi", u'açısı'), ("aci", u'açı'), ("minimize", ), ("gayri", u'gayrı'), ("Pandas", ), ("algoritma", ), ("gayri", u'gayrı'), ("sigma", ), ("volatility", ), ("matris", ), ("frac", "frac"), ("sonum", u"sönüm"), ("eksen", ), ("sonusur", u"sonuşur"), ("amaci", u"amacı"), ("amacimiz", u"amacımız"), ("sarsim", u"sarsım"), ("Sarsim", u"Sarsım"), (u"olduğu", )] r_list_coded = [] for x in r_list: r_list_coded.append((x[0], str(int(random.random() * 1000000)))) for x in r_list_coded: content = content.replace(x[0], x[1]) result = to_tr(content) for x in r_list_coded: result = result.replace(x[1], x[0]) for x in r_list: if len(x) == 2: result = result.replace(x[0], x[1]) lisp.delete_region(block_begin, block_end) lisp.insert(result) lisp.goto_char(remember_where)
def find_imports(): print "test hello" fname=lisp.buffer_file_name() print "remember:" + lisp.buffer_name() os.environ['BUFFER'] = lisp.buffer_name() remember_where = lisp.point() try: fname=lisp.buffer_file_name() project = Project(fname) thing, start = thing_at_point_regex("\W", "\W") print "thing:"+thing imports = project.find_file_for_import(thing) if (len(imports) > 1): ready_output() lisp.insert("\n") for item in imports: lisp.insert(item) lisp.insert("\n") elif (len(imports) == 1): put_import(fname, imports[0]) elif (len(imports) == 0): lisp.message("No import found for " + imports[0]) lisp.goto_char(remember_where) except Exception, e: lisp.message(e)
def emacs_engine(self, flag, find_limits): """\ Rebox text while obeying FLAG. Call FIND_LIMITS to discover the extent of the boxed comment. """ # `C-u -' means that box style is to be decided interactively. if flag == lisp['-']: flag = self.ask_for_style() # If FLAG is zero or negative, only change default box style. if isinstance(flag, int) and flag <= 0: self.default_style = -flag lisp.message("Default style set to %d" % -flag) return # Decide box style and refilling. if flag is None: style = self.default_style refill = True elif isinstance(flag, int): if self.default_style is None: style = flag else: style = merge_styles(self.default_style, flag) refill = True else: flag = flag.copy() if isinstance(flag, list): style = self.default_style refill = False else: lisp.error("Unexpected flag value %s" % flag) # Prepare for reboxing. lisp.message("Reboxing...") checkpoint = lisp.buffer_undo_list.value() start, end = find_limits() text = lisp.buffer_substring(start, end) width = lisp.fill_column.value() tabify = lisp.indent_tabs_mode.value() is not None point = lisp.point() if start <= point < end: position = point - start else: position = None # Rebox the text and replace it in Emacs buffer. old_style, new_style, text, position = engine( text, style=style, width=width, refill=refill, tabify=tabify, position=position) if text is None: lisp.error("Cannot rebox to style %d" % new_style) lisp.delete_region(start, end) lisp.insert(text) if position is not None: lisp.goto_char(start + position) # Collapse all operations into a single one, for Undo. self.clean_undo_after(checkpoint) # We are finished, tell the user. if old_style == new_style: lisp.message("Reboxed with style %d" % old_style) else: lisp.message("Reboxed from style %d to %d" % (old_style, new_style))
def _make_buffer(self, name, contents, empty_goto=True, switch=False, window='other', modes=[], fit_lines=None): """Make an emacs buffer `window` can be one of `None`, 'current' or 'other'. """ new_buffer = lisp.get_buffer_create(name) lisp.set_buffer(new_buffer) lisp.toggle_read_only(-1) lisp.erase_buffer() if contents or empty_goto: lisp.insert(contents) for mode in modes: lisp[mode + '-mode']() lisp.buffer_disable_undo(new_buffer) lisp.toggle_read_only(1) if switch: if window == 'current': lisp.switch_to_buffer(new_buffer) else: lisp.switch_to_buffer_other_window(new_buffer) lisp.goto_char(lisp.point_min()) elif window == 'other': new_window = lisp.display_buffer(new_buffer) lisp.set_window_point(new_window, lisp.point_min()) if fit_lines and lisp.fboundp(lisp['fit-window-to-buffer']): lisp.fit_window_to_buffer(new_window, fit_lines) lisp.bury_buffer(new_buffer) return new_buffer
def convert(): remember_where = lisp.point() block_begin, block_end, content = get_block_content("\n\n","\n\n") # alttaki listeye dokunulmamasi istenen kelimeler tek ogeli # tuple olarak yazilir, ("kelime",) gibi. eger degisim isteniyorsa # ("kelime","degisim") olarak bir tuple eklenir. r_list = [("verisi",),("Calculus",),("AIC",),("estimator",),(" ise",), ("kontur",),("ODE",),("Oklit",u'Öklit'),("karekok",u'karekök'), ("kismi", u'kısmi'),("integral",),("oldugu",u'olduğu'), ("acilimi",u'açılımı'),("acilim",u'açılım'),("aci",u'açı'), ("minimize",),("gayri",u'gayrı'),("Pandas",),("algoritma",), ("gayri",u'gayrı'),("sigma",),("volatility",),("matris",)] r_list_coded = [] for x in r_list: r_list_coded.append((x[0],str(int(random.random() * 1000000)))) for x in r_list_coded: content = content.replace(x[0],x[1]) result = to_tr(content) for x in r_list_coded: result = result.replace(x[1],x[0]) for x in r_list: if len(x)==2: result = result.replace(x[0],x[1]) lisp.delete_region(block_begin, block_end) lisp.insert(result) lisp.goto_char(remember_where)
def get_buffer_content_prev(bend): where_am_i = lisp.point() lisp.beginning_of_buffer() st = lisp.point() s = lisp.buffer_substring(st, bend) lisp.goto_char(where_am_i) return s
def get_block_content(start_tag, end_tag): remember_where = lisp.point() block_begin = lisp.search_backward(start_tag) lisp.goto_char(remember_where) block_end = lisp.search_forward(end_tag) content = lisp.buffer_substring(block_begin, block_end) lisp.goto_char(remember_where) return block_begin, block_end, content
def get_block_content(start_tag, end_tag): remember_where = lisp.point() block_begin = lisp.search_backward(start_tag) block_end = lisp.search_forward(end_tag) block_end = lisp.search_forward(end_tag) content = lisp.buffer_substring(block_begin, block_end) lisp.goto_char(remember_where) return block_begin, block_end, content
def from_rest(): text = get_text() parts = docutils.core.publish_parts(text, writer=Writer()) lisp.weblogger_start_entry() lisp.insert(parts['title']) lisp.goto_char(lisp.point_max()) lisp.insert(parts['body'])
def _goto_location(self, resource, lineno, point=None, other=False): if resource: self.env.find_file(str(resource.real_path), resource.project != self.project, other=other) if point: lisp.goto_char(point) if lineno: self.env.goto_line(lineno)
def get_block_content(start_tag, end_tag): remember_where = lisp.point() block_end = lisp.search_forward(end_tag) block_begin = lisp.search_backward(start_tag) content = lisp.buffer_substring(block_begin, block_end) content = re.sub("\\\\begin{minted}.*?{python}","",content) content = re.sub("\\\\end{minted}","",content) lisp.goto_char(remember_where) return block_begin, block_end, content
def occurrences_next(arg, reset): lisp.switch_to_buffer_other_window('*rope-occurrences*', True) if reset: lisp.goto_char(lisp.point_min()) lisp.forward_line(arg) if lisp.eobp(): lisp.message("Cycling rope occurences") lisp.goto_char(lisp.point_min()) occurrences_goto()
def genall(): remem = lisp.point() lisp.beginning_of_buffer() res = True while res: res = lisp.re_search_forward("$$[[:ascii:][:nonascii:]]*?$$",None,lisp.t) lisp.backward_char(3) show() lisp.goto_char(remem)
def get_block_content(start_tag, end_tag): remember_where = lisp.point() block_end = lisp.search_forward(end_tag) block_begin = lisp.search_backward(start_tag) content = lisp.buffer_substring(block_begin, block_end) content = re.sub("\\\\begin{minted}.*?{python}", "", content) content = re.sub("\\\\end{minted}", "", content) lisp.goto_char(remember_where) return block_begin, block_end, content
def pop_excursion(self): method, (buffer, point_marker, mark_marker) = self.stack[-1] assert method == 'excursion', self.stack[-1] del self.stack[-1] lisp.set_buffer(buffer) lisp.goto_char(point_marker) lisp.set_mark(mark_marker) lisp.set_marker(point_marker, None) if mark_marker is not None: # needed for xemacs lisp.set_marker(mark_marker, None)
def genall(): remem = lisp.point() lisp.beginning_of_buffer() res = True while res: res = lisp.re_search_forward("$$[[:ascii:][:nonascii:]]*?$$", None, lisp.t) lisp.backward_char(3) show() lisp.goto_char(remem)
def verb_exists(): remem = lisp.point() lisp.forward_line(2) lisp.beginning_of_line() verb_line_b = lisp.point() lisp.end_of_line() verb_line_e = lisp.point() verb_line = lisp.buffer_substring(verb_line_b, verb_line_e) lisp.goto_char(remem) if "\\begin{verbatim}" in verb_line: return True else: return False
def goto_definition(): """ go to definition/declaration of the pointer we are looking at """ fname=lisp.buffer_file_name() a = Project(fname) thing, start = thing_at_point(RIGHT1, LEFT1) lisp.message(thing) pos = lisp.point() type, pos = a.find_declaration_type(thing, fname, pos) lisp.goto_char(pos)
def verb_exists(): remem = lisp.point() lisp.forward_line(1) lisp.beginning_of_line() verb_line_b = lisp.point() lisp.end_of_line() verb_line_e = lisp.point() verb_line = lisp.buffer_substring(verb_line_b, verb_line_e) lisp.goto_char(remem) if "```text" in verb_line: return True else: return False
def insert_text(text,offset=0): """Insert text in buffer and move cursor to a certain offset. If called with no offset, leaves the cursor at the current position.""" # save undo state so we can roll everything into a single operation for undo checkpoint = lisp.buffer_undo_list.value() user_pos = lisp.point() lisp.insert(text) lisp.goto_char(user_pos+offset) # Collapse all operations into a single one, for Undo. clean_undo_after(checkpoint)
def occurrences_goto_occurrence(self): self._check_project() start = lisp.line_beginning_position() end = lisp.line_end_position() line = lisp.buffer_substring_no_properties(start, end) tokens = line.split() if tokens: resource = self.project.get_resource(tokens[0]) offset = int(tokens[2]) lisp.find_file_other_window(resource.real_path) lisp.goto_char(offset + 1) lisp.switch_to_buffer_other_window('*rope-occurrences*')
def insert_text(text, offset=0): """Insert text in buffer and move cursor to a certain offset. If called with no offset, leaves the cursor at the current position.""" # save undo state so we can roll everything into a single operation for undo checkpoint = lisp.buffer_undo_list.value() user_pos = lisp.point() lisp.insert(text) lisp.goto_char(user_pos + offset) # Collapse all operations into a single one, for Undo. clean_undo_after(checkpoint)
def occurrences_goto(): if lisp.line_number_at_pos() < 3: lisp.forward_line(3 - lisp.line_number_at_pos()) lisp.end_of_line() end = lisp.point() lisp.beginning_of_line() line = lisp.buffer_substring_no_properties(lisp.point(), end) tokens = line.split() if tokens: filename = tokens[0] offset = int(tokens[-1]) resource = _interface._get_resource(filename) LispUtils().find_file(resource.real_path, other=True) lisp.goto_char(offset + 1)
def occurrences_goto_occurrence(): lisp.end_of_line() end = lisp.point() lisp.beginning_of_line() start = lisp.point() line = lisp.buffer_substring_no_properties(start, end) tokens = line.split() if tokens: filename = tokens[0] offset = int(tokens[-1]) resource = _interface._get_resource(filename) LispUtils().find_file(resource.real_path, other=True) lisp.goto_char(offset + 1) lisp.switch_to_buffer_other_window('*rope-occurrences*')
def pick_method(): ''' pick the whole line from the list of function calls (completions) ''' print "in pick method" thing, start = thing_at_point(RIGHT2, LEFT2) prev_buffer = os.environ['BUFFER'] print "-"+prev_buffer+"-" lisp.kill_buffer(lisp.get_buffer("*PyJde*")) lisp.switch_to_buffer(prev_buffer) lisp.insert(thing) pos = lisp.point() print "pos="+(str(pos-1)) lisp.goto_char(pos-1) lisp.delete_other_windows()
def put_import (fname, imp): print "in put_import" print fname print imp content = lisp.buffer_substring(1, lisp.point()) print content for m in re.finditer("(import\s.*?);", content): print "mgroup="+m.group(1) print imp if (re.search(imp, m.group(1))): lisp.message("Already imported") return insert_where = re.search("import\s.*;", content).span()[1] lisp.goto_char(insert_where + 1) lisp.insert("\nimport " + imp + ";")
def convert(): remember_where = lisp.point() block_begin, block_end, content = get_block_content("\n\n","\n\n") content = content.replace("verisi","WWXXD1") content = content.replace("Calculus","WWXXD2") content = content.replace("AIC","WWXXD3") content = content.replace("estimator","WWXXD5") content = content.replace(" ise","WWXXD7") content = content.replace("kontur","WWXXD8") content = content.replace("ODE","WWXXD9") content = content.replace("Oklit","WWXXDx3") content = content.replace("karekok","WWXXDx4") content = content.replace("kismi","WWXXDx5") content = content.replace("integral","WWXXDx7") content = content.replace("acilimi","WWXXDx8") content = content.replace(" aci","WWXXDy1") content = content.replace("gayri","WWXXDy2") content = content.replace("oldugu","WWXXDy3") content = content.replace("Pandas","WWXXDy4") content = content.replace("algoritma","WWXXDy5") content = content.replace("minimize","WWXXDy6") result = to_tr(content) result = result.replace("WWXXD1","verisi") result = result.replace("WWXXD2","Calculus") result = result.replace("WWXXD3","AIC") result = result.replace("WWXXD5","estimator") result = result.replace("WWXXD7"," ise" ) result = result.replace("WWXXD8","kontur" ) result = result.replace("WWXXD9","ODE" ) result = result.replace('WWXXDx3',u'Öklit' ) result = result.replace('WWXXDx4',u'karekök' ) result = result.replace('WWXXDx5',u'kısmi' ) result = result.replace('WWXXDx7',u'integral' ) result = result.replace('WWXXDx8',u'acılımı' ) result = result.replace('WWXXDy1',u' açı' ) result = result.replace('WWXXDy2',u' gayrı' ) result = result.replace('WWXXDy3',u'olduğu' ) result = result.replace('WWXXDy4',u'Pandas' ) result = result.replace('WWXXDy5',u'algoritma' ) result = result.replace('WWXXDy6',u'minimize' ) lisp.delete_region(block_begin, block_end) lisp.insert(result) lisp.goto_char(remember_where)
def insert_indented_text(text,offset): """Insert indented text in buffer and move cursor to a certain offset.""" # save undo state so we can roll everything into a single operation for undo checkpoint = lisp.buffer_undo_list.value() # figure out if we are indented or not, and adapt text accordingly indent_level = get_line_offset() if indent_level > 0: text = indent(text,indent_level) # perform actual insertion with proper cursor positioning offset += indent_level lisp.beginning_of_line() user_pos = lisp.point() lisp.insert(text) lisp.goto_char(user_pos+offset) # Collapse all operations into a single one, for Undo. clean_undo_after(checkpoint)
def insert_indented_text(text, offset): """Insert indented text in buffer and move cursor to a certain offset.""" # save undo state so we can roll everything into a single operation for undo checkpoint = lisp.buffer_undo_list.value() # figure out if we are indented or not, and adapt text accordingly indent_level = get_line_offset() if indent_level > 0: text = indent(text, indent_level) # perform actual insertion with proper cursor positioning offset += indent_level lisp.beginning_of_line() user_pos = lisp.point() lisp.insert(text) lisp.goto_char(user_pos + offset) # Collapse all operations into a single one, for Undo. clean_undo_after(checkpoint)
def pop_mark(self): marker_ring = self.get('marker_ring') if lisp.ring_empty_p(marker_ring): self.message("There are no more marked buffers in \ the rope-marker-ring") else: oldbuf = lisp.current_buffer() marker = lisp.ring_remove(marker_ring, 0) marker_buffer = lisp.marker_buffer(marker) if marker_buffer is None: lisp.message("The marked buffer has been deleted") return marker_point = lisp.marker_position(marker) lisp.set_buffer(marker_buffer) lisp.goto_char(marker_point) #Kill that marker so it doesn't slow down editing. lisp.set_marker(marker, None, None) if not lisp.eq(oldbuf, marker_buffer): lisp.switch_to_buffer(marker_buffer)
def display_results(end_block, res): lisp.goto_char(end_block) lisp.forward_line(2) lisp.beginning_of_line() verb_line_b = lisp.point() lisp.end_of_line() verb_line_e = lisp.point() verb_line = lisp.buffer_substring(verb_line_b, verb_line_e) if "\\begin{verbatim}" in verb_line: verb_begin,verb_end,content = get_block_content("\\begin{verbatim}","\\end{verbatim}") lisp.delete_region(verb_begin, verb_end) lisp.goto_char(verb_begin) else: lisp.backward_line_nomark(1) lisp.insert("\n") res=res.replace("\r","") lisp.insert("\\begin{verbatim}\n") lisp.insert(res) lisp.insert("\\end{verbatim}")
def pexec(): global glob start = time.time() remember_where = lisp.point() block_begin, block_end, content = get_block_content("\n","\n") if "=" in content or "import" in content: c = compile(source=content,filename="",mode="single") eval(c,glob) else: c = compile(source=content,filename="",mode="eval") res = eval(c,glob) lisp.forward_line(2) bb1, be2, bc2 = get_block_content("\n","\n") lisp.delete_region(bb1,be2) lisp.insert("\n") lisp.insert(str(res)) lisp.goto_char(remember_where) elapsed = (time.time() - start) lisp.message("Ran in " + str(elapsed) + " seconds")
def show(): b,e,res = get_block_content("$$","$$") d = hash(res) foutsimple = "_preview/f-%d.png" % d if os.path.isfile(foutsimple): return # do nothing latex(res) curr_dir = os.path.dirname(lisp.buffer_file_name()) fout = "%s/_preview/f-%d.png" % (curr_dir,d) shutil.copy(dir + "\standalone.png",fout) remem = lisp.point() lisp.goto_char(e) lisp.forward_line(1) lisp.beginning_of_line(); bb = lisp.point() lisp.end_of_line(); ee = lisp.point() lisp.delete_region(bb,ee) lisp.insert("%{{" + foutsimple + "}}") lisp.goto_char(remem) lisp.iimage_mode(1)
def pick_import(): ''' pick the whole line from the list of imports ''' print "in pick import" thing, start = thing_at_point_regex("\n", "\n") prev_buffer = os.environ['BUFFER'] print "-"+prev_buffer+"-" lisp.kill_buffer(lisp.get_buffer("*PyJde*")) lisp.switch_to_buffer(prev_buffer) remember_where = lisp.point() content = lisp.buffer_substring(1, lisp.point()) insert_where = re.search("package\s.*;", content).span()[1] lisp.goto_char(insert_where + 1) lisp.insert("\n\nimport " + thing + ";") lisp.message(thing + " is imported") lisp.goto_char(remember_where) lisp.delete_other_windows()
def show(): b, e, res = get_block_content("$$", "$$") d = hash(res) foutsimple = "_preview/f-%d.png" % d if os.path.isfile(foutsimple): return # do nothing latex(res) curr_dir = os.path.dirname(lisp.buffer_file_name()) fout = "%s/_preview/f-%d.png" % (curr_dir, d) shutil.copy(dir + "\standalone.png", fout) remem = lisp.point() lisp.goto_char(e) lisp.forward_line(1) lisp.beginning_of_line() bb = lisp.point() lisp.end_of_line() ee = lisp.point() lisp.delete_region(bb, ee) lisp.insert("%{{" + foutsimple + "}}") lisp.goto_char(remem) lisp.iimage_mode(1)
def convert(): remember_where = lisp.point() block_begin, block_end, content = get_block_content("\n\n", "\n\n") content = content.replace("verisi", "WWXXD1") content = content.replace("Calculus", "WWXXD2") content = content.replace("AIC", "WWXXD3") content = content.replace("\sigma", "WWXXD4") content = content.replace("estimator", "WWXXD5") content = content.replace("\frac", "WWXXD6") content = content.replace("entegral", "didibin") content = content.replace(" ise", "WWXXD7") result = to_tr(content) result = result.replace("WWXXD1", "verisi") result = result.replace("WWXXD2", "Calculus") result = result.replace("WWXXD3", "AIC") result = result.replace("WWXXD4", "\sigma") result = result.replace("WWXXD5", "estimator") result = result.replace("WWXXD6", "\frac") result = result.replace("didibin", "entegral") result = result.replace("WWXXD7", " ise") lisp.delete_region(block_begin, block_end) lisp.insert(result) lisp.goto_char(remember_where)
def run_py_code(): remember_where = lisp.point() # check if the line contains \inputminted lisp.beginning_of_line() l1 = lisp.point() lisp.end_of_line() l2 = lisp.point() line = lisp.buffer_substring(l1, l2) # if code comes from file # get code content from latex block_begin, block_end, content = get_block_content("```python", "```\n") # we have code content at this point # scan content to find plt.plot(). if there is, scan buffer # previous to *here* to determine order of _this_ plt.plot(), and # give it an appropiate index that will be appended to the end of # the .png image file, i.e. [buffer name]_[index].png. plt.plot() # commands will be replaced by the corresponding plt.savefig # command. # generate savefig for execution code (no output in emacs yet) bc = lisp.buffer_string() plt_count_before = len(re.findall('plt\.savefig\(', bc)) base = os.path.splitext(lisp.buffer_name())[0] f = '%s_%s.png' % (base, two_digit(plt_count_before + 1)) rpl = "plt.savefig('%s')" % f show_replaced = True if "plt.show()" in content else False content = content.replace("plt.show()", rpl) content = "plt.figure();\n" + content include_graphics_command = "![](%s)" % f # we have code content at this point start = time.time() with capture_output() as io: res_code = get_ip().run_cell(content) res = io.stdout elapsed = (time.time() - start) if len(res) > 0: display_results(block_end, res) # display it if show_replaced: lisp.goto_char(block_end) lisp.forward_line(2) # skip over end verbatim, leave one line emtpy lisp.insert('\n' + include_graphics_command + '\n') lisp.scroll_up(1) # skip over end verbatim, leave one line emtpy lisp.goto_char(remember_where) lisp.replace_string("plt.show()", rpl, None, block_begin, block_end) lisp.goto_char(remember_where) lisp.message("Ran in " + str(elapsed) + " seconds")
def display_results(end_block, res): remem = lisp.point() res = res.replace("\r", "") lisp.goto_char(end_block) verb_begin = None # if there is output block, remove it whether there output or not # because it will be replaced anyway if something exists if verb_exists(): verb_begin, verb_end, content = get_block_content("```text", "```\n") lisp.delete_region(verb_begin, verb_end) lisp.goto_char(remem) # now if there _is_ output, then go to beginning of old verbatim # output (if removed), if not, this is brand new output, move # down 2 lines, insert the output if verb_begin: lisp.goto_char(verb_begin) else: lisp.forward_line(1) lisp.insert("```text\n") lisp.insert(res) lisp.insert("```\n")
def find_comment(self): """\ Find and return the limits of the block of comments following or enclosing the cursor, or return an error if the cursor is not within such a block of comments. Extend it as far as possible in both directions. """ let = Let().push_excursion() try: # Find the start of the current or immediately following comment. lisp.beginning_of_line() lisp.skip_chars_forward(' \t\n') lisp.beginning_of_line() if not language_matcher[0](self.remainder_of_line()): temp = lisp.point() if not lisp.re_search_forward('\\*/', None, lisp.t): lisp.error("outside any comment block") lisp.re_search_backward('/\\*') if lisp.point() > temp: lisp.error("outside any comment block") temp = lisp.point() lisp.beginning_of_line() lisp.skip_chars_forward(' \t') if lisp.point() != temp: lisp.error("text before start of comment") lisp.beginning_of_line() start = lisp.point() language = guess_language(self.remainder_of_line()) # Find the end of this comment. if language == 2: lisp.search_forward('*/') if not lisp.looking_at('[ \t]*$'): lisp.error("text after end of comment") lisp.end_of_line() if lisp.eobp(): lisp.insert('\n') else: lisp.forward_char(1) end = lisp.point() # Try to extend the comment block backwards. lisp.goto_char(start) while not lisp.bobp(): if language == 2: lisp.skip_chars_backward(' \t\n') if not lisp.looking_at('[ \t]*\n[ \t]*/\\*'): break if lisp.point() < 2: break lisp.backward_char(2) if not lisp.looking_at('\\*/'): break lisp.re_search_backward('/\\*') temp = lisp.point() lisp.beginning_of_line() lisp.skip_chars_forward(' \t') if lisp.point() != temp: break lisp.beginning_of_line() else: lisp.previous_line(1) if not language_matcher[language]( self.remainder_of_line()): break start = lisp.point() # Try to extend the comment block forward. lisp.goto_char(end) while language_matcher[language](self.remainder_of_line()): if language == 2: lisp.re_search_forward('[ \t]*/\\*') lisp.re_search_forward('\\*/') if lisp.looking_at('[ \t]*$'): lisp.beginning_of_line() lisp.forward_line(1) end = lisp.point() else: lisp.forward_line(1) end = lisp.point() return start, end finally: let.pops()
def run_py_code(): remember_where = lisp.point() # check if the line contains \inputminted lisp.beginning_of_line() l1 = lisp.point() lisp.end_of_line() l2 = lisp.point() line = lisp.buffer_substring(l1, l2) # if code comes from file if "\\inputminted" in line: block_begin = lisp.point() lisp.message(line) py_file = re.search("\{python\}\{(.*?)\}", line).groups(1)[0] # get code content from file curr_dir = os.path.dirname(lisp.buffer_file_name()) content = open(curr_dir + "/" + py_file).read() block_end = l2 # end of block happens to be end of include file line lisp.goto_char(remember_where) else: # get code content from latex block_begin, block_end, content = get_block_content( "\\begin{minted}", "\\end{minted}") # we have code content at this point # scan content to find plt.plot(). if there is, scan buffer # previous to *here* to determine order of _this_ plt.plot(), and # give it an appropiate index that will be appended to the end of # the .png image file, i.e. [buffer name]_[index].png. plt.plot() # commands will be replaced by the corresponding plt.savefig # command. # generate savefig for execution code (no output in emacs yet) bc = lisp.buffer_string() plt_count_before = len(re.findall('plt\.savefig\(', bc)) base = os.path.splitext(lisp.buffer_name())[0] f = '%s_%s.png' % (base, two_digit(plt_count_before + 1)) rpl = "plt.savefig('%s')" % f show_replaced = True if "plt.show()" in content else False content = content.replace("plt.show()", rpl) content = "plt.figure()\n" + content include_graphics_command = "\\includegraphics[height=6cm]{%s}" % f #(ip) = get_kernel_pointer(lisp.buffer_name()) start = time.time() with capture_output() as io: res_code = get_ip().run_cell(content) res = io.stdout elapsed = (time.time() - start) display_results(block_end, res) # display it # generate includegraphics command if show_replaced: lisp.forward_line(2) # skip over end verbatim, leave one line emtpy lisp.insert(include_graphics_command + '\n') lisp.scroll_up(1) # skip over end verbatim, leave one line emtpy lisp.goto_char(remember_where) lisp.replace_string("plt.show()", rpl, None, block_begin, block_end) lisp.goto_char(remember_where) if "plt.savefig" in content: lisp.preview_buffer() lisp.message("Ran in " + str(elapsed) + " seconds")
def run_py_code(): remember_where = lisp.point() # check if the line contains \inputminted lisp.beginning_of_line() l1 = lisp.point() lisp.end_of_line() l2 = lisp.point() line = lisp.buffer_substring(l1, l2) # if code comes from file if "\\inputminted" in line: lisp.message(line) py_file = re.search("\{python\}\{(.*?)\}", line).groups(1)[0] # get code content from file curr_dir = os.path.dirname(lisp.buffer_file_name()) content = open(curr_dir + "/" + py_file).read() block_end = l2 # end of block happens to be end of include file line lisp.goto_char(remember_where) else: # get code content from latex block_begin, block_end, content = get_block_content( "\\begin{minted}", "\\end{minted}") #lisp.message(content) # we have code content at this point # scan content to find plt.plot(). if there is, scan buffer # previous to *here* to determine order of _this_ plt.plot(), and # give it an appropiate index that will be appended to the end of # the .png image file, i.e. [buffer name]_[index].png. plt.plot() # commands will be replaced by the corresponding plt.savefig # command. # generate savefig for execution code (no output in emacs yet) bc = get_buffer_content_prev(block_begin) plt_count_before = len(re.findall('plt\.savefig\(', bc)) base = os.path.splitext(lisp.buffer_name())[0] f = '%s_%s.png' % (base, two_digit(plt_count_before + 1)) rpl = "plt.savefig('%s')" % f show_replaced = True if "plt.show()" in content else False content = content.replace("plt.show()", rpl) include_graphics_command = "\\includegraphics[height=6cm]{%s}" % f (kc, kernel, ip) = get_kernel_pointer(lisp.buffer_name()) start = time.time() res = '' with capture_output() as io: ip.run_cell(content) res = io.stdout if kernel.shell.last_known_outflag: etype, value, tb = kernel.shell._get_exc_info() res = str(etype) + " " + str(value) + "\n" elapsed = (time.time() - start) # replace this unnecessary message so output becomes blank if res and len(res) > 0: # if result not empty res = res.replace( "Populating the interactive namespace from numpy and matplotlib\n", "") display_results(block_end, res) # display it else: display_results(block_end, "") lisp.goto_char(block_end) # generate includegraphics command if show_replaced: lisp.forward_line(2) # skip over end verbatim, leave one line emtpy lisp.insert(include_graphics_command + '\n') lisp.backward_line_nomark( 1) # skip over end verbatim, leave one line emtpy lisp.goto_char(remember_where) lisp.replace_string("plt.show()", rpl, None, block_begin, block_end) lisp.goto_char(remember_where) if "plt.savefig" in content: lisp.preview_buffer() lisp.message("Ran in " + str(elapsed) + " seconds")
def insert_line(self, line, lineno): current = lisp.point() lisp.goto_line(lineno) lisp.insert(line + '\n') lisp.goto_char(current + len(line) + 1)