gernophil's questions

Eu tenho o aplicativo na parte inferior. Agora, tenho este campo predefinido onde posso selecionar entre 3 opções (+ a opção changed). O que eu quero é poder definir o input_option com o campo predefinido. Mas também quero poder alterá-lo manualmente. Se eu alterar o input_option manualmente, o campo predefinido deve mudar para changed. O problema é que, se eu definir a opção com o campo predefinido, isso aciona automaticamente a segunda função e define o input_preset de volta para changed. Mas isso só deve acontecer se eu alterá-lo manualmente, não se for alterado pela primeira função reativa. Isso é possível de alguma forma? Tentei um pouco com reactive.isolate(), mas isso não parece ter nenhum efeito.

from shiny import App, ui, reactive


app_ui = ui.page_fillable(
    ui.layout_sidebar(
        ui.sidebar(
            ui.input_select("input_preset", "input_preset", choices=["A", "B", "C", "changed"]),
            ui.input_text("input_option", "input_option", value=''),
        )
    )
)


def server(input, output, session):


    @reactive.effect
    @reactive.event(input.input_preset)
    def _():
        if input.input_preset() != 'changed':
            # with reactive.isolate():
                ui.update_text("input_option", value=str(input.input_preset()))


    @reactive.effect
    @reactive.event(input.input_option)
    def _():
        ui.update_select("input_preset", selected='changed')


app = App(app_ui, server)

Olá, estou tentando alterar alguns estilos CSS de um script JavaScript externo (igv.js). Estou executando esse script incorporado em um arquivo HTML, conforme sugerido aqui .

<div id="igv_div">
<script type="module">
    import igv from "https://cdn.jsdelivr.net/npm/[email protected]/dist/igv.esm.min.js"
    const div = document.getElementById("igv_div")
    const config = {
            genome: "hg19"
    }
    const browser = await igv.createBrowser(div, config) 
</script>
</div>

Consegui mudar algumas cores globalmente de uma só vez usando algo assim:

<style>
#igv_div {filter: invert(88%);}
</style>

No entanto, nada do que tento altera elementos individuais. Quando simplesmente tento definir o estilo CSS de um elemento no cabeçalho HTML, parece que isso é completamente ignorado.

<style>
.igv-track-label {color: red;}
</style>

No entanto, posso manipulá-lo usando o seletor diretamente no navegador, então acho que o estilo está codificado em algum lugar do próprio script e substitui meu CSS modificado. Existe alguma maneira de substituir o estilo do script sem alterá-lo, ao executá-lo a partir de um arquivo HTML?

Estou quebrando a cabeça com essa pergunta, provavelmente bem simples, e não consigo encontrar a resposta em lugar nenhum. Quero criar uma nova coluna com a soma agrupada de outra coluna, mas quero manter todas as linhas individuais. Então, aqui está o que a documentação diz:

import polars as pl

df = pl.DataFrame(
    {
        "a": ["a", "b", "a", "b", "c"],
        "b": [1, 2, 1, 3, 3],
    }
)

df.group_by("a").agg(pl.col("b").sum())  

O resultado disso seria:

shape: (3, 2)
┌─────┬─────┐
│ a   ┆ b   │
│ --- ┆ --- │
│ str ┆ i64 │
╞═════╪═════╡
│ a   ┆ 2   │
│ c   ┆ 3   │
│ b   ┆ 5   │
└─────┴─────┘

No entanto, o que eu preciso é disto:

shape: (5, 3)
┌─────┬─────┬────────┐
│ a   ┆ b   ┆ sum(b) │
│ --- ┆ --- ┆ ------ │
│ str ┆ i64 ┆ i64    │
╞═════╪═════╪════════╡
│ a   ┆ 1   ┆ 2      │
│ b   ┆ 2   ┆ 5      │
│ a   ┆ 1   ┆ 2      │
│ b   ┆ 3   ┆ 5      │
│ c   ┆ 3   ┆ 3      │
└─────┴─────┴────────┘

Eu poderia criar a soma em um df separado e depois uni-la ao original, mas tenho certeza de que há uma solução mais fácil.

A cor padrão do cabeçalho para DataFrames ( render.DataGrid(), render.DataTable()) é um cinza bem claro (provavelmente gainsboro). Se eu alternar um aplicativo para o modo escuro usando um DataFrame, o cabeçalho se torna ilegível. Existe alguma maneira de fazer um dict dizer ao shiny qual cor usar para a cor gainsboroou para um objeto específico, se eu alternar para o modo escuro?

Aqui está um MRE (não tão minimalista):

from shiny import App, render, ui
import polars as pl

app_ui = ui.page_fillable(
    ui.layout_sidebar(
        ui.sidebar(ui.input_dark_mode()),
        ui.layout_columns(
            ui.card(
                ui.card_header("card_header1", style='background:gainsboro'),
                ui.output_data_frame("card1"),
                full_screen=True
            ),
            col_widths=12
        )
    )
)

def server(input, output, session):

    @output
    @render.data_frame
    def card1():
        return render.DataGrid(pl.DataFrame({'a': ['a','b','c','d']}), filters=True)

app = App(app_ui, server)

Quero estilizar CSS meu Shiny para campos de entrada Python, mas de alguma forma não funciona. No entanto, posso estilizar os cabeçalhos do cartão. Alguém sabe o que estou fazendo errado? Ou os elementos ui.input* não podem ser estilizados diretamente?

from shiny import App, render, ui, reactive
from pathlib import Path


app_ui = ui.page_fillable(
    ui.panel_title(
        ui.row(
        ui.column(12, ui.h1("title1")),
        )
    ),
    ui.layout_sidebar(
        ui.sidebar(
            ui.input_text("input_text1", "input_text1", value=""),
            ui.input_selectize("input_selectize1", "input_selectize1", choices=["1", "2"]),
            ui.input_numeric("input_numeric1", "input_numeric1", value=4),
            ui.input_switch("input_switch1", "input_switch1", value=False),
            ui.input_action_button("input_action_button1", "input_action_button1"),
            width="350px"
        ),
        ui.layout_columns(
            ui.card(
                ui.card_header("card_header1"),
                ui.output_data_frame("card1"),
                full_screen=True
            ),
            col_widths=12
        )
    ),
    ui.tags.style(
    ".card-header { color:white; background:#2A2A2A !important; }",
    ".input-text { color:red; height:0px; }",
    ".input-numeric { color:red; height:0px; }")
)


def server(input, output, session):

    @reactive.event(input.input_action_button1)
    def reactive_function1():
        pass

    @output
    @render.data_frame
    def card1():
        return reactive_function1()

src_dir = Path(__file__).parent / "src"
app = App(app_ui, server, static_assets=src_dir)

Como você deve ter percebido pelas minhas outras perguntas, estou em transição de pandas para polars agora. Tenho um df polars com listas aninhadas de forma diferente, como esta:

┌────────────────────────────────────┬────────────────────────────────────┬─────────────────┬──────┐
│ col1                               ┆ col2                               ┆ col3            ┆ col4 │
│ ---                                ┆ ---                                ┆ ---             ┆ ---  │
│ list[list[str]]                    ┆ list[list[str]]                    ┆ list[str]       ┆ str  │
╞════════════════════════════════════╪════════════════════════════════════╪═════════════════╪══════╡
│ [["a", "a"], ["b", "b"], ["c", "c"]┆ [["a", "a"], ["b", "b"], ["c", "c"]┆ ["A", "B", "C"] ┆ 1    │
│ [["a", "a"]]                       ┆ [["a", "a"]]                       ┆ ["A"]           ┆ 2    │
│ [["b", "b"], ["c", "c"]]           ┆ [["b", "b"], ["c", "c"]]           ┆ ["B", "C"]      ┆ 3    │
└────────────────────────────────────┴────────────────────────────────────┴─────────────────┴──────┘

Agora quero unir as listas de dentro para fora usando separadores diferentes para chegar a isso:

┌─────────────┬─────────────┬───────┬──────┐
│ col1        ┆ col2        ┆ col3  ┆ col4 │
│ ---         ┆ ---         ┆ ---   ┆ ---  │
│ str         ┆ str         ┆ str   ┆ str  │
╞═════════════╪═════════════╪═══════╪══════╡
│ a+a-b+b-c+c ┆ a+a-b+b-c+c ┆ A-B-C ┆ 1    │
│ a+a         ┆ a+a         ┆ A     ┆ 2    │
│ b+b-c+c     ┆ b+b-c+c     ┆ B-C   ┆ 3    │
└─────────────┴─────────────┴───────┴──────┘

Eu faço isso usando map_elementsum loop for, mas acho que é altamente ineficiente. Existe uma maneira nativa polars de gerenciar isso?

Aqui está meu código:

import polars as pl

df = pl.DataFrame({"col1": [[["a", "a"], ["b", "b"], ["c", "c"]], [["a", "a"]], [["b", "b"], ["c", "c"]]],
                   "col2": [[["a", "a"], ["b", "b"], ["c", "c"]], [["a", "a"]], [["b", "b"], ["c", "c"]]],
                   "col3": [["A", "B", "C"], ["A"], ["B", "C"]],
                   "col4": ["1", "2", "3"]})

nested_list_cols = ["col1", "col2"]
list_cols = ["col3"]

for col in nested_list_cols:
    df = df.with_columns(pl.lit(df[col].map_elements(lambda listed: ['+'.join(element) for element in listed], return_dtype=pl.List(pl.String))).alias(col)) # is the return_dtype always pl.List(pl.String)?
for col in list_cols + nested_list_cols:
    df = df.with_columns(pl.lit(df[col].list.join(separator='-')).alias(col))

Tenho estes dados:

┌────────────┬─────────────────────────────────────┐
│ col1       ┆ col2                                │
│ ---        ┆ ---                                 │
│ list[str]  ┆ list[list[str]]                     │
╞════════════╪═════════════════════════════════════╡
│ ["a"]      ┆ [["a"]]                             │
│ ["b", "c"] ┆ [["b", "c"], ["b", "c"], ["b", "c"] │
│ ["d"]      ┆ [["d"]]                             │
└────────────┴─────────────────────────────────────┘

Quero ter todos os b's e todos os c's na mesma lista na linha 2, mas como você pode ver, as associações de b com b e de c com c não são mantidas na linha 2. Com pandas, usei:

import pandas as pd

pddf = pd.DataFrame({"col1": [["a"], ["b", "c"], ["d"]],
                     "col2": [[["a"]], [["b", "c"], ["b", "c"], ["b", "c"]], [["d"]]]})

pddf["col2"] = pddf["col2"].apply(lambda listed: pd.DataFrame(listed).transpose().values.tolist())

print(pddf)

#      col1                    col2
# 0     [a]                   [[a]]
# 1  [b, c]  [[b, b, b], [c, c, c]]
# 2     [d]                   [[d]]

Este é o resultado desejado. Estou tentando fazer o mesmo com polars, substituindo pddf.transpose().values.tolist()por pldf.transpose().to_numpy().tolist(), mas sempre obtenho and TypeError: not yet implemented: Nested object types. Há alguma solução alternativa? Aqui está o código polars completo:

import polars as pl

pldf = pl.DataFrame({"col1": [["a"], ["b", "c"], ["d"]],
                     "col2": [[["a"]], [["b", "c"], ["b", "c"], ["b", "c"]], [["d"]]]})

pldf = pldf.with_columns(pl.col("col2").map_elements(lambda listed: pl.DataFrame(listed).transpose().to_numpy().tolist()))

print(pldf)

# TypeError: not yet implemented: Nested object types
# Hint: Try setting `strict=False` to allow passing data with mixed types.

Onde eu precisaria aplicar o mencionado strict=False?

Em um df mais fácil pddf.transpose().values.tolist()e pldf.transpose().to_numpy().tolist()são os mesmos:

import pandas as pd
import polars as pl

pd.DataFrame(
    {"col1": ["a", "b", "c"],
     "col2": ["d", "e", "f"]}
     ).transpose().values.tolist() == pl.DataFrame(
                                          {"col1": ["a", "b", "c"],
                                           "col2": ["d", "e", "f"]}
                                           ).transpose().to_numpy().tolist()

# True

Por favor, mantenha-se o mais próximo possível do código, mesmo que não seja o ideal usar .apply()ou .map_elements(), mas isso é um projeto muito maior e não quero quebrar mais nada :).

(EDIT: Simplifiquei um pouco o código, já que o segundo lambda não era realmente necessário para a pergunta.)

Tenho um dataframe pandas onde um valor às vezes obtém NA. Quero preencher esta coluna com uma lista de strings com o mesmo comprimento de outra coluna:

import pandas as pd
import numpy as np

df = pd.DataFrame({"a": ["one", "two"],
                   "b": ["three", "four"],
                   "c": [[1, 2], [3, 4]],
                   "d": [[5, 6], np.nan]})

e eu quero que isso se torne

tentei

df["d"] = np.where(df.d.isna(),
                   ['no_value' for element in df.c],
                   df.d)

e

df["d"] = np.where(df.d.isna(),
                   ['no_value'] * len(df.c),
                   df.d)

mas ambos não funcionam. Alguém tem uma ideia?

SOLUÇÃO: Ajustei um pouco a resposta de Paul para:

df[‘d‘] = np.where(df.d.isna(), 
                   pd.Series([['no_value'] * len(lst) for lst in df.c]), 
                   df.d))

Ei, eu tenho um DataFrame que consiste em 44 colunas. a primeira coluna é um nome e todas as outras colunas são variáveis ​​que podem ser sim/VERDADEIRO ou não/FALSO. Cada nome pode ter várias linhas e quero combinar todas as entradas para um nome e uma variável no campo como no exemplo resumido abaixo. Porém, para 43 colunas não quero fazer isso manualmente, pois sou preguiçoso e é mais sujeito a erros. Alguma idéia de como fazer isso? Também tenho uma lista com todos os nomes das colunas que quero combinar:

library(tidyverse)

df <- tibble(name = c("A", "A", "A", "B", "C", "C"),
             variable_one = c(TRUE, FALSE, TRUE, FALSE, FALSE, FALSE),
             variable_two = c(FALSE, FALSE, FALSE, TRUE, FALSE, TRUE),
             variable_three = c(FALSE, TRUE, TRUE, FALSE, FALSE, TRUE)) |>
  group_by(name) |>
  summarise(
    variable_one = paste(variable_one, collapse = ","),
    variable_two = paste(variable_two, collapse = ","),
    variable_three = paste(variable_three, collapse = ","),
  )

Quero descarregar todos os submódulos que pertencem a um módulo específico, porque entra em conflito com outro módulo. Aqui está o que eu faço:

mainmodule_submodules = [key for key in sys.modules if key.startswith('mainmodule')]
for mainmodule_submodule in mainmodule_submodules:
    del mainmodule_submodule # deletes the variable mainmodule_submodule instead of the submodule that's stored in it
    del sys.modules[mainmodule_submodule]

O problema é que isso exclui a variável mainmodule_submodulecriada pelo loop for em vez do módulo que está armazenado com o valor de mainmodule_submodule. Como eu faço isso?