jupyter notebook

%%script false --no-raise-error

https://stackoverflow.com/questions/19309287/how-to-intermittently-skip-certain-cells-when-running-ipython-notebook
As a heads up, this gets rid of existing output. Not useful if you want to keep previous output of the cell.
En Jupytext te lo exporta con comentarios

https://docs.anaconda.com/anaconda/user-guide/tasks/remote-jupyter-notebook/

jupyter notebook --no-browser --port=<PORT>

• https://github.com/deshaw/jupyterlab-execute-time
  pip install jupyterlab_execute_time
  
• https://github.com/jupyter-lsp/jupyterlab-lsp → sospecho que ha sido fácil de instalar porque ya tenía node y lsp instalado por neovim
  pip install 'python-lsp-server[all]' jupyterlab-lsp
  Te añade una carpeta .virtual_documents
  

La norma general es que tengo que instalar todas las dependencias en el entorno virtual, y Jupyter sólamente en el entorno global
Sin embargo para ciertas cosas como estas, tienes que instalarlo también en el entorno global, porque utiliza ese por defecto
Otra alternativa es lanzarla desde el propio entorno virtual

• https://github.com/lckr/jupyterlab-variableInspector
  

Por defecto si pones un breakpoint() no te va a funcionar, pero esto sí
import sys; sys.__breakpointhook__()
También otra cosa que puedes hacer es utilizar el debugger de JupyterLab
https://github.com/jupyterlab/jupyterlab/issues/10996

https://github.com/jupyterlab/jupyterlab_app#download
App de escritorio de JupyterLab basada en Electron

https://link.medium.com/WnHABjepEbb

• Window management
  
  
• Open the same notebook side by side (tab Left click> New view for notebook)
  
  

• Workspaces
  

    cat ~/.jupyter/lab/workspaces/* | jq -r '.metadata.id'
  

Jupytext - Jupyter Notebooks as Markdown Documents, Julia, Python or R Scripts — Jupytext documentation
Empareja distintos tipos de archivos (ipynb con md, ipynb con python con/sin celdas de markdown)
In JupyterLab, Jupytext adds a set of commands to the command palette (View / Activate Command Palette, or Ctrl+Shift+C):

!Parece que es simplemente cuestión de que tienes que salir del navegador!
Al menos cuando no te da un error de Python como el de abajo pero te sigue sin funcionar

[E 2022-03-16 16:02:07.749 ServerApp] Uncaught exception GET /lab/api/settings?1647442927412 (127.0.0.1)
    HTTPServerRequest(protocol='http', host='localhost:8889', method='GET', uri='/lab/api/settings?1647442927412', version='HTTP/1.1', remote_ip='127.0.0.1')
    Traceback (most recent call last):
      File "/home/julian/.local/lib/python3.9/site-packages/tornado/web.py", line 1704, in _execute
        result = await result
    tornado.iostream.StreamClosedError: Stream is closed

Quizás tiene sentido ponerle una configuración para que lance un navegador específico, distinto del que utilizo para navegar, que ocupe poca RAM, optimizado…

https://github.com/jupyter/notebook/issues/5814
Hice esto y lo reinstalé con pip en $HOME:

sudo apt remove python3-jupyter-core python3-nbformat
# Esto me desinstala esto: python3-jupyter-core python3-nbformat python3-plotly python3-qgis qgis qgis-plugin-grass
# Tiene dependencias con qgis
# qgis → python3-qgis → python3-plotly → python3-nbformat → python3-jupyter-core
pip3 uninstall -y jupyter jupyter_core jupyter-client jupyter-console notebook qtconsole nbconvert nbformat
pip3 install jupyter jupyter_core jupyter-client jupyter-console notebook qtconsole nbconvert nbformat

Esto también puede que tenga que ver:

ERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.
quilt3 3.5.0 requires jsonschema==3.*, but you have jsonschema 4.4.0 which is incompatible.

Con pip install 'jsonschema==3.*' se soluciona

https://stackoverflow.com/questions/67390716/unable-to-install-jupyterlab-execute-time-extension

Extension authors targeting the JupyterLab 3.0+ can choose to either:
1. continue publishing on NPM and ignore the new federated extensions mechanism, or
2. adapt federated extensions and start publishing to PyPI/conda-forge only, or
3. publish to both NPM and PyPI/conda-forge
In case of =jupyterlab-execute-time= the author went the (2) route, only publishing to PyPI/conda-forge, with the latest published release as for the day of writing being 2.0.2 on PyPI;

• Todas las que tiene Jupyter Lab
  https://jupyterlab-contrib.github.io/extensions.html
  
• Las correspondencias con las que tenía Jupyter Notebook
  https://jupyterlab-contrib.github.io/migrate_from_classical.html
  

https://stackoverflow.com/questions/47772157/how-to-change-the-default-browser-used-by-jupyter-notebook-in-windows
https://github.com/jupyterlab/jupyterlab/issues/9565

jupyter server --generate-config
c.ServerApp.browser = 'chromium'

En Windows, parece que tienes que instalar Jupyter Lab en el entorno virtual, lanzarlo desde allí y generar un kernel a la vez, porque si lo ejecutas desde el entorno base te falla la importación por ejemplo de numpy porque no encuentra las librerías binarias
https://docs.anaconda.com/anaconda/user-guide/tasks/integration/python-path/ → Para pillar el PATH de Python

source ~/Anaconda/Scripts/activate
source ~/anaconda3/Scripts/activate
# Para convertir los \ de Windows en / de shell
jupyter kernelspec list | sed 's%\\%/%g' | awk -n 'NR >= 2 {print $2}' | xargs -I _ /bin/bash -c "ls _/kernel.json && cat _/kernel.json"

https://github.com/marimo-team/marimo
https://news.ycombinator.com/item?id=39552882

• A marimo tutorial as a WASM notebook: https://marimo.app/l/c7h6pz
  
• Training a neural network with Karpathy’s micrograd: https://marimo.app/l/xpd4te
  
• Visualizing attractors, as a read-only app: https://marimo.app/l/e9wii1?mode=read
  
• A blank notebook: https://marimo.new
  

• github - Quarto
  

• quarto render Untitled.qmd --to org para renderizar a org mode
  Hay que ponerle esto para que no tarde mucho
  

    org:
      execute:
        eval: false
  

“What You Need to Know About Netflix’s ‘Jupyter Killer’: Polynote 📖” por
Michael Li https://link.medium.com/lop9sIcfN8 “Netflix’s Polynote is a New Open
Source Framework to Build Better Data Science Notebooks” por Jesus Rodriguez
https://link.medium.com/BAoJIl2iV8

https://deepnote.com/

https://www.reddit.com/r/Python/comments/on8m3o/jupyter_launches_jupyterlite_a_lightweight/

• JupyterLite: Jupyter ❤️ WebAssembly ❤️ Python | by Jeremy Tuloup | Jupyter Blog
  

Uses also Pyodide

https://edu.kde.org/cantor/ Soporta muchos backends, es más como Sagemath

https://towardsdatascience.com/jypyter-notebook-shortcuts-bf0101a98330

• Shortcuts in both modes:
  
  • Shift + Enter run the current cell, select below
    
  • Ctrl + Enter run selected cells
    
  • Alt + Enter run the current cell, insert below
    
  • Ctrl + S save and checkpoint
    
• While in command mode (press Esc to activate):
  
  • Enter take you into edit mode
    
  • H show all shortcuts
    
  • Up select cell above
    
  • Down select cell below
    
  • Shift + Up extend selected cells above
    
  • Shift + Down extend selected cells below
    
  • A insert cell above
    
  • B insert cell below
    
  • X cut selected cells
    
  • C copy selected cells
    
  • V paste cells below
    
  • Shift + V paste cells above
    
  • D, D (press the key twice) delete selected cells
    
  • Z undo cell deletion
    
  • S Save and Checkpoint
    
  • Y change the cell type to Code
    
  • M change the cell type to Markdown
    
  • P open the command palette.
    
  • This dialog helps you run any command by name. It’s really useful if you don’t know some shortcut or when you don’t have a shortcut for the wanted command.
    
• Command Palette
  
  • Shift + Space scroll notebook up
    
  • Space scroll notebook down
    
• While in edit mode (pressEnter to activate)
  
  • Esc take you into command mode
    
  • Tab code completion or indent
    
  • Shift + Tab tooltip
    
  • Ctrl + ] indent
    
  • Ctrl + [ dedent
    
  • Ctrl + A select all
    
  • Ctrl + Z undo
    
  • Ctrl + Shift + Z or Ctrl + Y redo
    
  • Ctrl + Home go to cell start
    
  • Ctrl + End go to cell end
    
  • Ctrl + Left go one word left
    
  • Ctrl + Right go one word right
    
  • Ctrl + Shift + P open the command palette
    
  • Down move cursor down
    
  • Up move cursor up
    

https://github.com/dunovank/jupyter-themes
https://medium.com/@rbmsingh/making-jupyter-dark-mode-great-5adaedd814db
jt -t monokai -f firacode -fs 12 -N -kl -cursw 5 -cursc r -cellw 95% -T -ofs 12 -dfs 12
Para resetear el tema: jt -r
Lo malo es que las imágenes de los notebooks tienen la leyenda en negro y con transparencia y no se ve nada, asumen fondo claro. Después de ejecutarlo ya funciona bien
Luego le pongo el contraste al máximo en el Dark Reader

• https://github.com/nat-chan/vim.wasm.ipynb Esto recopila las dos
  
  • https://github.com/wmvanvliet/jupyter-vim
    
  • https://github.com/lambdalisue/jupyter-vim-binding (esta es la que uso)
    
• Shift+Esc para ir a nivel de celda (modo notebook), o, O
  
• i para insertar (se va a la celda pero en modo vim)
  
• H ayuda atajos de teclado (modo notebook)
  
• Shift+Enter para ejecutar y saltar a la siguiente, Ctrl+Enter para ejecutar y quedarse
  
• Ctrl+Shift+Enter → run all cells
  
• 0,0 → restart kernel
  
• https://opensource.com/sites/default/files/gated-content/osdc_cheatsheet-jupyterlab_1.pdf
  
  • Ctrl+Shift+[, Ctrl+Shift+] para saltar entre tabs
    
  • Shift+L → in cell mode, toggle line numbers
    

  pip install jupyter_contrib_nbextensions
  jupyter contrib nbextension install --user
  pip install jupyter_nbextensions_configurator
  jupyter nbextensions_configurator enable --user

https://medium.com/swlh/some-neat-jupyter-tricks-be0775c3f17

• ESC+00 Para reiniciar el kernel
  
• ESC+Z Para deshacer el borrado de una celda
  

  from IPython.core.interactiveshell import InteractiveShell
  InteractiveShell.last_node_interactivity = "all" # "last_expr" por defecto
  # Imprimir

Poner notebook al 100% de ancho

  from IPython.core.display import display, HTML
  display(HTML("<style>.container { width:100% !important; }</style>"))

\sigma[TAB] autocompleta y crea variables de python con letras griegas

breakpoint en jupyter

from IPython.core.debugger import Pdb; Pdb().set_trace()

https://github.com/marhop/pandoc-unicode-math

No va muy bien cuando tienes muchos datos (incluso con ~10000 ya va lento)
En principio instalando orjson va más rápido pero lo he instalado y no he notado nada (también puede ser porque estoy en python 3.8)
https://dash.plotly.com/performance

Formerly nbsafety

Por si quieres meter un DataFrame en un diccionario. También está interesante porque te permite guardar resultados en disco

• Persisting lru_cache to disk while using hashable pandas objects for parallel experiments · GitHub
  No funciona si recargo el notebook, no sé si parándolo y reiniciando funciona
  
• Hashable DataFrames and Series for caching.py · GitHub
  
• Los kernels de Jupyter crean por cada kernel una carpeta, __main__--tmp-ipykernel-2546379442 en vez de __main__ que sería lo suyo
  

= Para funciones, crea uno por cada archivo, estilo: __main__--home-julian-Work-1projects-chatgpt-chatgpt-prompt, pero no utiliza el de __main__, y copiando/pegando tampoco funciona

• %%writefile file.py
  Para escribir a archivos externos desde jupyter (pasar funciones a .py pero tenerlo todo en un mismo notebook, pueden estar ocultos, marcarse como saltarlas por defecto, que no se exporten a JupyText esas celdas)
  
• %bookmark <nombre> <dir> → cd -b <nombre>
  Por ejemplo si haces una exportación a un directorio distinto para manterer el tuyo limpio
  
• %edit
  
• %load → cargar script (embeber)
  
• %logon, %logstart → logging
  
• %save te ejecuta una celda (expandiendo los comandos % y con rango de líneas opcionales) y guarda stdout en un archivo
  
• %%capture → write stdout to file
  

Cachear tablas sql? Se puede incluir fecha de última modificación como parte de los argumentos que toma la función para que si cambia se recalcule automáticamente (esta petición tiene que ser mucho más rápida que hacer la petición entera o si no no estamos ganando nada)
Existe hash de una tabla para detectar si ha cambiado? Con fecha de última modificación debería valer
Parsear sql para sacar las tablas de origen (from, join, …)

• @jupyter-widgets/jupyterlab-manager
  The JupyterLab extension providing Jupyter widgets.
  
• jupyterlab-nbsafety
  JupyterLab extension for nbsafety user interface
  
• bqplot
  bqplot
  
• jupyterlab_pygments
  Pygments theme using JupyterLab CSS variables
  
• ipytree
  A Tree Widget using jsTree
  
• jupyterlab-vimrc
  add a basic vimrc to jupyterlab
  
• ipydatagrid
  Fast Datagrid widget for the Jupyter Notebook and JupyterLab
  
• jupyterlab-plotly
  The plotly Jupyter extension
  
• jupyterlab-system-monitor
  JupyterLab extension to display system information
  
• jupyterlab-topbar-extension
  JupyterLab extension to expose the top bar space
  
• jupyterlab-sql-editor
  SQL editor support for formatting, syntax highlighting and code completion of SQL in cell magic, line magic, python string and file editor.
  
• jupyterlab-execute-time
  Display cell timings in Jupyter Lab
  
• jupyterlab-jupytext
  Save Jupyter Notebooks as Scripts or Markdown files that work well with version control & external text editors
  
• @axlair/jupyterlab_vim
  Code cell vim bindings
  
• @jupyter-server/resource-usage
  JupyterLab extension to add resource usage UI items
  
• @krassowski/jupyterlab-lsp
  Language Server Protocol integration for JupyterLab
  
• @hokyjack/jupyterlab-monokai-plus
  A Monokai++ theme extension for JupyterLab
  
• jupyterlab-dash
  A JupyterLab extensions for rendering Plotly Dash apps
  
• @aquirdturtle/collapsible_headings
  Make headings collapsible like the old Jupyter notebook extension and like e.g. mathematica notebooks.
  

Pipeline de exploración de datos

Fuente de datos ↘ ↗ img
función cacheada (joblib/pickle o postgres django) → latex
where, parámetros ↗ ↘ backend interactivo, PyQt, Plotly

→ LAs imgs las tienes etiquetadas y con fecha, listo para poder buscar con fecha, con caché en disco
Te da igual qué utilices mientras guarde una imagen
La estrategia de tags depende del SO
Puedes recalcular de manera rápida, pero lo mejor es una imagen si tienes que enseñar algo rápido
Con Matplotlib tienes muchos widgets (pero no vale para web)
Plotly parece que no aguanta muchos puntos (500,000 le cuesta)
PyQt Agg rasteriza los puntos, y es muy eficiente
%matplotlib widget es interactivo y guarda imagen (pero se sobreescribe)

Hacer un checkbox que sea jerárquico (por ejemplo agrupas en función de la zona geográfica y del edificio, y los edificios siempre están contenidos en una misma zona geográfica que activa/desactiva todos los edificios de esa zona), escalable en función de si hay muchos puntos. Plotly utiliza scroll pero eso no lo tienes en matplotlib, aunque sí en PyQt quizás
Esto en Folium es un FeatureGroup
Otra cosa de plotly es datos temporales (fecha en hover)
Los formatos de fecha de matplotlib son complicados d eusar (añadir más granularidad es complicado y fastidia lo que ya está hecho por defecto)
Añádir un folium para resolver casos extraños
Idealmente deberías de tener un mapa que se recarga en notebook (con número fijo de puntos para que no llene la ram), con AntPath para mostrar dirección
Se salta 1 de cada X puntos si hay muchos (asumiendo que están cerca, o quitar los puntos muy cercanos, o combinar los 2 criterios)
Es complicado añadir interactividad a Matplotlib: se asume variables globales que actualizan las cosas, porque se llaman “fuera” de cualquier función. Está pensado para scripts

Estilo aplicar de algún color un dataframe en jupyter para que se vea color (html)

from IPython import get_ipython
from IPython.core.magic import Magics, magics_class, line_magic

@magics_class
class MyMagics(Magics):

    @line_magic
    def lmagic(self, line):
        "Replace current line with new output"
        raw_code = 'print("Hello world!")'
        # Comment out this line if you actually want to run the code.
        self.shell.set_next_input('%lmagic\n{}'.format(raw_code), replace=False)
        self.shell.set_next_input('%lmagic\n{}'.format(raw_code), replace=False)
        # Uncomment this line if you want to run the code instead.
        self.shell.run_cell(raw_code, store_history=False)

ip = get_ipython()
ip.register_magics(MyMagics)

• Si pones replace=True se sobreescribe a sí mismo, si pones replace=False escribe la siguiente celda y puedes hacer múltiples celdas, puede ser un iterable
  Parece que va de abajo arriba
  

from IPython import get_ipython
from IPython.core.magic import Magics, magics_class, line_magic
a = 1
@magics_class
class MyMagics(Magics):

    @line_magic
    def lmagic(self, line):
        "Replace current line with new output"
        raw_code = 'print("Hello world!")'
        # Comment out this line if you actually want to run the code.
        self.shell.set_next_input(f'a = {a}'.format(raw_code), replace=False)
        self.shell.run_cell('a += 1', store_history=False)
        # Uncomment this line if you want to run the code instead.
        self.shell.run_cell(raw_code, store_history=False)

ip = get_ipython()
ip.register_magics(MyMagics)

Lo que quedaría ahora sería convertir ese tipo de celda en markdown

Tiene que estar invertido porque es un stack (primero crea la última)
Puedo hacerlo una lista y luego invertirla
Hay que cambiar el tipo a celda de markdown (seleccionar varias con shift) y te queda unas celdas que son colapsables en Jupyter Lab

from IPython import get_ipython
from IPython.core.magic import Magics, magics_class, line_magic
a = 6
@magics_class
class MyMagics(Magics):

    @line_magic
    def lmagic(self, line):
        self.shell.set_next_input('#' * a + f' Headline \nEsto es un headline de nivel {a}', replace=False)
        self.shell.run_cell('a -= 1', store_history=False)

ip = get_ipython()
ip.register_magics(MyMagics)

Lo siguiente que quedaría sería modificarlo para que:

1. Sea una celda de tipo Markdown
   
2. Que tenga jp-MarkdownHeadingCollapsed=true
   
3. Meterle tags para ya hacer lo que te da un poco la gana
   

Lo que saca por percent script es esto:

No puedes hacer un set_next_input dos veces, parece. Guarda algún tipo de estado, incluso si pones replace=False por cada intro sólo consigo que rellene una celd
Otra cosa más prometedora parece Python Markdown, que al parecer es una extensión para jupyter notebook (clásico) que te permite poner variables de Python entre corchetes y te las renderiza

• python - How to programmatically generate markdown output in Jupyter notebooks? - Stack Overflow
  Con el Display no funciona el collapsable
  
  • Allowing variable references in Markdown cells · Issue #1098 · jupyter/notebook · GitHub
    
  • Allow references to Python variables in Markdown cells · Issue #2958 · ipython/ipython · GitHub
    
  • Module: display — IPython 8.9.0 documentation
    
  • jupyter_contrib_nbextensions/src/jupyter_contrib_nbextensions/nbextensions/python-markdown at master · ipython-contrib/jupyter_contrib_nbextensions · GitHub
    
• Include variables in Markdown cells of JupyterLab Notebooks - Data Dive
  
• Inline variable insertion in markdown - Notebook - Jupyter Community Forum
  
• Inline variable insertion in markdown - Notebook - Jupyter Community Forum
  

https://towardsdatascience.com/bring-your-jupyter-notebook-to-life-with-interactive-widgets-bc12e03f0916
Editarlo como si fuese input
The solution to this is to capture the cell output in a special kind of widget, namely Output, and then display it in another cell.