How to send multiple lines in single block with ipython

[txnf]

in ipython when I send a cell or block of lines to terminal with repl_send_motion, it always send the block and evaluates it one line at a time.. Is there a way to make it send it to ipython, or to format it so that ipython will evaluate it as a single block?

Thank you

Example below:

# %%
fig, ax = plt.subplots(1,1)
t = np.linspace(-1, 10, 1000)
ax.plot(t, (np.sqrt(1 + (2*t)**2)-1)/2)

I get:

In [66]: fig, ax = plt.subplots(1,1)

In [67]: t = np.linspace(-1, 10, 1000)

In [68]: ax.plot(t, (np.sqrt(1 + (t/10)**2)-1)*10)
Out[68]: [<matplotlib.lines.Line2D at 0x71a0b80cf890>]

I wish that it would evaluate it as one block instead.

[frere-jacques]

Hi, this is not possible, but you can install jupyter-console via pip and then use the following repl definition:

python = {
  command = { "jupyter-console", "--ZMQTerminalInteractiveShell.image_handler=None" },
  format = require("iron.fts.common").bracketed_paste,
  block_deviders = { "# %%", "#%%" },
},

The option , "--ZMQTerminalInteractiveShell.image_handler=None" can be removed to get the jupyter-console default image display.

I had a look today at https://github.com/jupyter-vim/jupyter-vim. They open qtconsole in an extra window and attach it to the jupyter-console kernel. I can do now the same and can see the repl output like images in qtconsole while sending with iron code from my buffer to the python-console in the nvim buffer. This works even, if the iron buffer is hidden.

Just start the repl in iron and then in a different terminal run jupyter qtconsole --existing --ConsoleWidget.include_other_output=True or set this option in the config file, like instructed in jupyter-vim.

[txnf]

Thank you! I will give it a try.

[frere-jacques]

Might be that using ipython kernel and just using this format might work too.

[frere-jacques]

Yes,just removing the _python in the example config is enough. I guess the _python is only needed if one uses python as repl. For ipython and jupyter-console the other function is more useful.

[g0t4]

@txnf I was able to execute multiple lines in one "cell" by using bracketed_paste:

python = {
  command = { "ipython", "--no-autoindent" },
  format = require("iron.fts.common").bracketed_paste
}

I don't know if it's a bug, or if it should work that way... Only issue is it sends everything as a single cell and so the output is a giant blob with no correlation back to the original code.

And, I prefer cell-per-line (using bracketed_paste_python) semantics b/c the line of code serves as an implicit label, so I don't have to add labels to all my print statements. In this case I use a function to wrap multiple lines into one "cell" b/c it's one statement that gets sent for eval:

def elementwiseMult():
    pricesRow = torch.tensor([5, 1.5, 2])
    costsPerItem = orders * pricesRow
    expectedCostsPerItem = torch.tensor([
        [5,3,6],
        [0,3,0],
        [0,0,2],
    ], dtype=torch.float16)
    np.testing.assert_array_equal(costsPerItem, expectedCostsPerItem)
elementwiseMult()

Bonus for using a func is you can stop executing on a failure, whereas I haven't found a way to do that with the cell-per-line style... I imagine that would require OSC codes specific to the REPL and they'd need to be emitted on a failure and picked up with a TermRequest event.

Hope it helps!