Yes, I know its sounds silly. But there *is* a point...

The R library reticulate allows to use a *persistent* Python session from a R session. One of its main uses is to allow to use Python code as well as R code in the creation of reports or papers. This is really useful for everyday statistics use...

One can do similar things with Sage and SageTeX, but using R and R objects is a bit awkward. Furthermore, the R tools offer abilities not easily emulated from within Sage. One *can* create composite documents using R facilities for R code (`knitr`

) and SageTeX (or PythonTeX, better maintained nowadays) for supporting Sage code ; but usng such composite documents is a bit awkward : passing from the source to the compiled document entails :

`knit`

the R code of the`.Rnw`

file, getting a`.tex`

file ;`\LaTeX`

the`.tex`

file at least once ;`sage`

(or`pythontex`

) the resultant file- re-
`\LaTeX`

the`.tex`

file at least once.

This is a bit hard to automate... The same thing applies with aggravation to Markdown texts : the Sage chunks have to be wrapped in \LaTeX-only chunks, and the sage steps have to be done manually from the command line (or from emacs, which amounts to the same thing).

The availability of a persistent Sage session would solve the problem.

A small trial using Sage's R (launched by `sage -R`

) shows that this is *almost* possible :

```
> library(reticulate)
> use_python("/usr/local/sage-8/sage") ## This is the main Sage script file
> repl_python()
Python 2.7.15 (/usr/local/sage-8/sage)
Reticulate 1.10 REPL -- A Python interpreter in R.
>>> 2^3
1
```

We are in python, no preparsing takes place.

```
>>> arctan
NameError: name 'arctan' is not defined
```

`arctan`

is not defined : noting Sage-specific is known.

```
>>> from sage.all import *
>>> arctan
arctan
```

The import succeeded.

```
>>> x
NameError: name 'x' is not defined
```

But the (default) definition of x as a symbolic variable has not been done.

```
>>> var("x")
x
>>> x
x
>>> foo=arctan(x).integrate(x)
>>> exit
```

We are back to R, from which we can access toplevel objects in the Python session :

```
> py$foo
x*arctan(x) - 1/2*log(x^2 + 1)
> py$latex(py$foo)
x \arctan\left(x\right) - \frac{1}{2} \, \log\left(x^{2} + 1\right)
> py_to_r(py$latex(py$foo))
x \arctan\left(x\right) - \frac{1}{2} \, \log\left(x^{2} + 1\right)
```

Not a "standard" R characer vector :

```
> class(py_to_r(py$latex(py$foo)))
[1] "sage.misc.latex.LatexExpr" "python.builtin.str"
[3] "python.builtin.basestring" "python.builtin.object"
```

But it can be used as such :

```
> paste("** ",py$latex(py$foo)," **", sep="")
[1] "** x \\arctan\\left(x\\right) - \\frac{1}{2} \\, \\log\\left(x^{2} + 1\\right) **"
```

Now, it is possible to insert the loading of a *Python* module *before* the launch of the Python REPL : From the doc of `repl_python`

:

module: An (optional) Python module to be imported before the REPL is launched.

So the question is : is it possible to write a module correctly importing `sage.all`

**AND** whose `__init__`

function would ** replace** Python's REPL by Sage's ?

ISTR that a few years ago, before the introduction of Sage's Jupyter notebook, such tricks were used in Jupyter to start a Sage session (complete with preparser) from an "ordinary" Jupyter notebook. But for the life of me, I haven't been able to retrieve the relevant pages...

Any thoughts ?