ipyflow

Tl; dr

Notebooks de Python reativos precisos para Jupyter [Lab]:

1. pip install ipyflow
2. Escolha Python 3 (ipyflow) do seletor de lançador ou kernel.
3. Para cada execução de células, o conjunto (mínimo) de células fora do sincronizador a montante e a jusante também reexectam, para que as células executadas apareçam como faria ao executar o notebook de cima para baixo.

Sobre

O IPYFlow é um kernel Python de próxima geração para o JupyterLab e o Notebook 7 que rastreia as relações de fluxo de dados entre símbolos e células durante uma determinada sessão interativa, facilitando a razão sobre o estado do notebook. Aqui está um vídeo da palestra JupyterCon que a apresenta (e slides correspondentes).

Se você quiser pular o passo do elevador e pular direto para as instruções de instalação / ativação, salte para começar rápido abaixo; Caso contrário, continue lendo para aprender sobre a filosofia e o conjunto de recursos do Ipyflow.

Metas

O IPYFlow fornece reatividade aparafusada ao kernel Python padrão de Jupyter, Ipykernel. Foi projetado com os seguintes objetivos em mente:

• Compatibilidade completa com o iPykernel: o IPYFlow pretende ser um substituto para o iPykernel, fornecendo um superconjunto rigoroso de seus recursos.
• Inferência precisa da dependência: o IpyFlow entende dependências entre células além de apenas variáveis ​​simples. Por exemplo, o IPYFlow entende quando a célula B depende da célula A por causa de uma referência de subscrito x[0] e é inteligente o suficiente para não executar reativamente a célula B quando alguma outra parte de x , por exemplo, x[1] , muda. Como resultado, limita a reexecução desnecessária ao mínimo.
• Execução destemida: o IpyFlow tenta fazer cumprir o seguinte invariante: sempre que você executa uma célula, a saída resultante aparece como faria se você tivesse realizado uma operação "reiniciar + executar tudo". A implicação é que você pode executar basicamente qualquer célula no notebook e confiar que ela apenas ^funciona .

Início rápido

Para instalar, execute:

pip install ipyflow

Para executar um kernel ipyflow, selecione "Python 3 (ipyflow)" na lista de kernels disponíveis na guia Launcher. Da mesma forma, você pode mudar para / do IpyFlow de um notebook existente navegando para o item de menu de arquivo "Alterar kernel":

Ponto de entrada	Kernel Switcher

Características

Modelo de execução reativa

IPYFlow Navios com extensões que trazem reatividade ao JupyterLab e notebook 7 por padrão, semelhante ao comportamento de execução oferecido em outros notebooks, como observável, pluto.jl e marimo.

A reatividade do Ipyflow se comporta um pouco diferente do que foi acima, no entanto, como foi projetado para atender às necessidades dos usuários de Jupyter em particular. Quando você executa a célula C com o IPYFlow, a saída de C , a saída das células C depende e a saída das células que dependem de C todas aparecem como faria se o notebook fosse executado de cima para baixo (por exemplo, através de "reiniciar e correr"). Quando você seleciona algumas células C , todas as células que reexecionariam quando C é executado, têm um ponto laranja ao lado delas, e as células que C depende, mas que estão atualizadas e não reexectam pontos roxos:

As informações de dependência celular são persistidas nos metadados do notebook, para que você possa pular para qualquer célula depois de iniciar uma nova sessão do kernel, executá -la e estar confiante de que a saída é o que se destinava ao autor do notebook:

AutoSave e recuperação de execuções anteriores

Como o IPYFlow espreita no estado de execução para inferir dependências, ele precisa manter o conteúdo do notebook sincronizado com o estado de memória do kernel, mesmo nas atualizações do navegador. Como tal, o IPYFlow permite o AutoSave-on-Change por padrão, de modo que o estado do kernel, o estado da interface do usuário do notebook e o arquivo de notebooks no disco estão todos sincronizados. Se você substituir acidentalmente a saída de uma célula que deseja manter, por exemplo, durante uma execução reativa e substitui o resultado anterior do resultado anterior, não tema! O IPYFlow fornece um utilitário da biblioteca chamado reproduce_cell para recuperar a entrada e saída de execuções de células anteriores (dentro de uma determinada sessão do kernel):

 from ipyflow import reproduce_cell
reproduce_cell ( 4 , lookback = 1 )  # to reproduce the previous execution of cell 4

Exemplo:

Optando por fora da reatividade

Se você deseja optar temporariamente da execução reativa, pode usar o Ctrl+Shift+Enter (no Mac, CMD+Shift+Enter também funciona) para executar apenas a célula em questão:

Você também pode executar o %flow mode normal na opção de exclusão do modo de execução reativa padrão (nesse caso, Ctr+Shift+Enter / CMD+Shift+Enter mudará de não reativo para reativo). Para reativar a execução reativa como padrão, você pode executar %flow mode reactive :

Se você quiser evitar o comportamento reativo padrão para cada nova sessão do kernel, poderá adicioná -lo ao seu perfil ipython (local padrão normalmente em ~/.ipython/profile_default/ipython_config.py ):

 c = get_config ()
c . ipyflow . exec_mode = "normal"  # defaults to "reactive"

Semântica em ordem e qualquer ordem

O IPYFlow padrão é a semântica em ordem , o que significa que, se a célula B depende da célula A , A deve aparecer antes de B na ordem espacial do notebook. O IPYFlow não impede que as células anteriores referenciem dados criados ou atualizados por células posteriores, mas omite essas arestas ao realizar a execução reativa.

A semântica em ordem, embora menos flexível, possui algumas propriedades desejáveis ​​quando comparadas com a semântica de qualquer ordem, pois incentivam os notebooks mais limpos e reproduzíveis que podem ser mais facilmente convertidos em scripts Python mais tarde. Agora que posso ou não ter vendido você em semântica em ordem, você pode permitir a semântica de qualquer ordem no IpyFlow executando a %flow direction any_order comando mágica e reencenando a semântica em ordem padrão usando a %flow direction in_order :

Você também pode atualizar seu perfil ipython se quiser tornar a semântica de qualquer ordem o comportamento padrão para novas sessões do kernel:

 c = get_config ()
c . ipyflow . flow_direction = "any_order"  # defaults to "in_order"

Sugestões de execução e atalho para resolver inconsistências

Sempre que uma célula faz referência a dados atualizados, o recolhimento ao lado é dado uma cor laranja (semelhante à cor das células sujas), e as células que (recursivamente) dependem dela recebem uma cor de colapso roxo. (Uma entrada laranja com uma saída roxa significa apenas que a saída pode estar fora de sincronização.) Ao usar a execução reativa, você geralmente não as verá, pois as células dependentes de sincronização serão executadas automaticamente, embora você possa vê-las se os dados atualizam (o Ctrl+shift+entra para optar temporariamente fora da reatividade ou se você altera os dados dos dados.

Se você deseja deixar o IpyFlow corrigi -las para você, poderá pressionar o "espaço" quando no modo de comando resolver todas as células obsoletas ou sujas. Esta operação pode introduzir células mais obsoletas; nesse caso, você pode continuar pressionando o "espaço" até que todas as inconsistências sejam resolvidas, se desejado:

Memórias

As células que referenciam funções e classes do Python, primitivas como números inteiros, carros alegóricos, cordas, além de matrizes numpy, quadros de dados e contêineres de pandas e contêineres (listas, ditos, conjuntos, tuplos, etc.) podem ser memorizados pelo IPYFlow usando o pseudomagic special %%memoize . Não há necessidade de especificar as "entradas" para a célula, pois o IpyFlow os inferirá automaticamente. As células memorizadas cache seus resultados na memória (embora os caches apoiados em disco estejam planejados para o futuro) e recuperarão esses resultados em cache (em vez de executar novamente a célula) sempre que o iPyflow detectar entradas e o conteúdo de células idêntico ao de uma execução anterior:

Por padrão, %%memoize ignora toda a saída, exceto a saída potencial do displayHook da última expressão na célula (quando aplicável). Para pular isso também, passe --quiet e incluir stdout, stderr e outros ricos saídas, passe --verbose :

Integração IpyWidgets

O mecanismo de execução reativo do IpyFlow possui suporte interno para ipywidgets , permitindo que as alterações nos widgets sejam propagadas entre os limites da célula:

Essa funcionalidade pode ser combinada com o %%memoize Magic para fornecer a renderização quase em tempo real de parcelas interativas entre as células:

Essa funcionalidade pode ser emparelhada com outras extensões, como o Stickyland, para criar painéis totalmente reativos em cima do JupyterLab + IpyFlow.

Finalmente, o IPYFlow também se integra aos widgets de mercúrio também:

API do estado

O IPYFlow deve entender o estado de execução subjacente em um nível profundo, a fim de fornecer seus recursos. Ele expõe uma API para interagir com parte desse estado, incluindo uma função code para obter o código necessário para reconstruir algum símbolo:

 # Cell 1
from ipyflow import code

# Cell 2
x = 0

# Cell 3
y = x + 1

# Cell 4
print ( code ( y ))

# Output:
"""
# Cell 2
x = 0

# Cell 3
y = x + 1
"""

Você também pode fazer isso no nível da célula também usando o método slice() :

 from ipyflow import cells
print ( cells ( 4 ). slice ())

# Output:
"""
# Cell 2
x = 0

# Cell 3
y = x + 1

# Cell 4
print(code(y))
"""

Você também pode ver a célula (1 indexada) e a declaração (0-indexada) de quando um símbolo foi atualizado pela última vez com a função timestamp :

 from ipyflow import timestamp
timestamp ( y )
# Timestamp(cell_num=3, stmt_num=0)

Para ver dependências e dependentes de um símbolo específico, use os deps e users , respectivamente:: respectivamente:

 from ipyflow import deps , users

deps ( y )
# [<x>]

users ( x )
# [<y>]

Se você deseja elevar um símbolo à representação usada internamente pelo Ipyflow, use a função lift (por sua conta e risco, é claro):

 from ipyflow import lift

y_sym = lift ( y )
y_sym . timestamp
# Timestamp(cell_num=3, stmt_num=0) 

Colab, vscode e outras interfaces

A reatividade e outros recursos do front -end ainda não estão funcionando em interfaces como Colab ou VSCode, mas você ainda pode usar a API de fluxo de dados do Ipyflow nessas superfícies, inicializando sua sessão de notebook com o seguinte código:

 %pip install ipyflow
%load_ext ipyflow

Citando

O IPYFlow iniciou sua vida sob o nome NbSafety, que forneceu as sugestões iniciais e a funcionalidade de corte.

Para as sugestões de execução:

 @article { macke2021fine ,
  title = { Fine-grained lineage for safer notebook interactions } ,
  author = { Macke, Stephen and Gong, Hongpu and Lee, Doris Jung-Lin and Head, Andrew and Xin, Doris and Parameswaran, Aditya } ,
  journal = { Proceedings of the VLDB Endowment } ,
  volume = { 14 } ,
  number = { 6 } ,
  pages = { 1093--1101 } ,
  year = { 2021 } ,
  publisher = { VLDB Endowment }
}

Para o slicer dinâmico (usado para reatividade e para a função code , por exemplo):

 @article { shankar2022bolt ,
  title = { Bolt-on, Compact, and Rapid Program Slicing for Notebooks } ,
  author = { Shankar, Shreya and Macke, Stephen and Chasins, Andrew and Head, Andrew and Parameswaran, Aditya } ,
  journal = { Proceedings of the VLDB Endowment } ,
  volume = { 15 } ,
  number = { 13 } ,
  pages = { 4038--4047 } ,
  year = { 2022 } ,
  publisher = { VLDB Endowment }
}

Para qualquer coisa que não esteja coberta nos documentos acima, você pode citar o repositório IPYFlow:

 @misc { ipyflow ,
  title = { {IPyflow: A Next-Generation, Dataflow-Aware IPython Kernel} } ,
  howpublished = { url{https://github.com/ipyflow/ipyflow} } ,
  year = { 2022 } ,
}

Agradecimentos

O IPYFlow não teria sido possível sem os incríveis colaboradores acadêmicos listados nos artigos acima. Seus recursos de execução reativos são inspirados nos de outras excelentes ferramentas, como notebooks hexadecimais, pluto.jl e observáveis. O IPYFlow também desfruta de polinização cruzada de idéias com outros notebooks reativos do Python como Marimo, Jolin.io e Datalore-definitivamente, confira-os também se você gosta de IpyFlow.

O trabalho no IPYFlow se beneficiou do apoio de pessoas de várias empresas - tanto na forma de contribuições financeiras diretas (Databricks, Hex) quanto como apoio e incentivo moral indiretos (ponder, meta). E, é claro, o IpyFlow repousa sobre as fundações construídas pela incrível comunidade Jupyter.

Licença

Código deste projeto licenciado sob a licença BSD-3-cláusula.

Expandir