All perguntas(coding)

Estou tentando extrair o texto desejado de um conjunto de texto fornecido. Criei a função abaixo.

   def extract_name(title):
        matches = re.findall(r'\b[A-Z0-9\s&.,()-]+(?:\s*\(\d\))?\b', title)
        return ', '.join(matches) if matches else None

Mas, ele produz indesejados (, ,para alguns títulos. Por exemplo, meus títulos são como abaixo.

THETA COMMERCIALS (2005) LIMITED, TEST CONNECTIONS LTD (In Relation), NANO CARE LIMITED (In Relation)

Resultado esperado:THETA COMMERCIALS (2005) LIMITED, TEST CONNECTIONS LTD, NANO CARE LIMITED

Tenho um projeto C++ no WSL e VS Code no lado do Windows. Digamos que meu binário C++ esteja em: /home/myhome/bin/test, então em /home/myhome, eu lanço o VS Code: >code . No VS Code, o launch.json é como:

{
    "version": "0.2.0",
    "configurations": [
        {
            "name": "WSL: Debug C++ Project",
            "type": "cppdbg",
            "request": "launch",
            "program": "${workspaceFolder}/bin/test",
            "args": [],
            "stopAtEntry": false,
            "cwd": "${workspaceFolder}",
            "environment": [],
            "externalConsole": false,
            "MIMode": "gdb",
            "setupCommands": [
                {
                    "description": "Enable pretty-printing for gdb",
                    "text": "-enable-pretty-printing",
                    "ignoreFailures": true
                }
            ],
            "preLaunchTask": "Build C++ Project"
        }
    ]
}

Mas durante a depuração, o VS Code reclama: \\wsl.localhost\Ubuntu\home\myhome: Nenhum arquivo ou diretório desse tipo

Eu também tentei:

{
    "version": "0.2.0",
    "configurations": [
        {
            "name": "WSL: Debug C++ Project",
            "type": "cppdbg",
            "request": "launch",
            "program": "/home/myhome/bin/test",
            "args": [],
            "stopAtEntry": false,
            "cwd": "/home/myhome",
            "environment": [],
            "externalConsole": false,
            "MIMode": "gdb",
            "setupCommands": [
                {
                    "description": "Enable pretty-printing for gdb",
                    "text": "-enable-pretty-printing",
                    "ignoreFailures": true
                }
            ],
            "preLaunchTask": "Build C++ Project"
        }
    ]
}

Desta vez, a mensagem de erro é "\home\myhome\bin\test" não pode ser encontrado. Percebi que na mensagem de erro ele se torna uma barra invertida. Alguém sabe o que está faltando aqui?

Há este programa mri_synthstrip que insere um arquivo de ressonância magnética cerebral e produz o mesmo arquivo de ressonância magnética cerebral excluindo o crânio. Este é um passo inicial básico para pré-processar ressonâncias magnéticas cerebrais para pesquisa.

O programa é maravilhoso e a sintaxe para remover a pele do crânio de uma única ressonância magnética é simples se você instalar o programa no seu computador:

mri_synthstrip -i input.nii.gz -o stripped.nii.gz

Os autores são muito simpáticos e até criaram uma imagem Docker que você pode extrair do Dockerhub com docker pull freesurfer/synthstrip

nesse caso a sintaxe para retirar o crânio de uma ressonância magnética do cérebro é

docker run -v C:/Users/ch134560/Desktop/MRI_files://data freesurfer/synthstrip -i //data/input.nii.gz -o //data/stripped.nii.gz

O que estou tentando fazer é criar uma imagem Docker que rode todos os arquivos MRI em um diretório e faça skull strips com synthstrip. Achei que isso seria fácil.

Meu Dockerfile multiestágio se parece com isso, mas não funciona porque não reconhece o comando no loop

freesurfer/synthstrip -i "$file" -o "$file"

ou

mri_synthstrip -i "$file" -o "$file"

Acho que não sei como chamar um comando específico dentro de um loop Unix.

#########STAGE 1: CREATE THE MOUNT AND COPY THE MRIs TO BE SKULL-STRIPPED#########

# Use ubuntu as base image
FROM ubuntu AS prepare

# Set working directory
WORKDIR /app

# Copy all MRIs
COPY . .

#########STAGE 2: USE SYNTHSTRIP#########
FROM freesurfer/synthstrip

# Set working directory
WORKDIR /app

# Copy all MRIs
COPY --from=prepare . .

# Create a loop that runs through the MRIs
RUN for file in .; do freesurfer/synthstrip -i "$file" -o "$file"; done

ENTRYPOINT ["ls"]

Outra opção que pensei é criar uma compilação de vários estágios na qual primeiro importo o programa synthstrip e depois faço um loop pelos arquivos MRI e chamo o synthstrip, mas, novamente, não sei exatamente como chamar o comando para executar o synthstrip a partir do python.

Arquivo Docker

#########STAGE 1: CREATE THE SYNTHSTRIP CONTAINER###########

# Use synthstrip AS base image
FROM freesurfer/synthstrip as builder

# Set working directory
WORKDIR /app

#########STAGE 2: CREATE THE ANACONDA CONTAINER###########

# Use miniconda as base image
FROM continuumio/miniconda3

# Set working directory
WORKDIR /app

# Copy the initial image
COPY --from=builder . .

# Create the environment
COPY environment.yml .
RUN conda env create -f environment.yml

# Make run commands use the new environment
SHELL ["conda", "run", "-n", "app", "bin/bash", "-c"]

# Code to run when the container is started
COPY main.py .
ENTRYPOINT ["conda", "run", "--no-capture-output", "-n", "app", "python", "main.py"]

arquivo main.py

import os
import subprocess

for MRI in os.listdir('./file_with_MRIs'):
    print(MRI)
    proc = subprocess.Popen(['docker run freesurfer/synthstrip -i ', MRI, ' -o', MRI],
                            stdin = subprocess.PIPE,
                            stdout = subprocess.PIPE,
                            stderr = subprocess.PIPE
                        )

    (out, err) = proc.communicate()
    print   (out)

Outra opção é criar uma imagem Docker menor que percorra os arquivos MRI e apenas chame a imagem Docker do synthstrip para cada um deles e colete a saída, mas não tenho certeza de como fazer isso.

Estou tentando seguir este tutorial para usar SignalR no ASP.NET, só por diversão. Mas vou usar o LibGen (que admito que nunca usei antes) para instalar a biblioteca do lado do cliente e meu cliente do Visual Studio me mostra isso, onde o nome da biblioteca é preenchido com Intellisense, mas não carrega nenhum arquivo da biblioteca.

E então quando tento incluir todos os arquivos da biblioteca e instalar, recebo o erroThe "@microsoft/signalr@latest" library could not be resolved by the "unpkg" provider

Tentei pesquisar esse problema procurando por problemas de instalação de bibliotecas ou problemas com a instalação do LibGen, mas, pelo que entendi, o LibGen deve funcionar imediatamente com o Visual Studio e a biblioteca em si é gerenciada pelo npm, que tenho no meu PC.

Alguém tem alguma ideia do que está errado aqui? É um problema de caixa preta real que estou lutando para resolver. Pensei em instalar o LibGen CLI como uma solução, mas estou esperando para ver se consigo hackear isso primeiro.

Estou usando uma consulta observável para observar alterações em um banco de dados Android Room e exibir os resultados em uma LazyColumn. Isso funciona bem, mas agora quero que o usuário consiga alterar a ordem de classificação. Com minha implementação atual, alterar a ordem de classificação não faz com que a LazyColumn se recomponha. Se outra parte do estado mudar, a LazyColumn se recomporá e a ordenação atualizada será refletida na visualização.

Meu DAO se parece com isso:

@Dao
interface EntityDao {
    @Query("SELECT * FROM entity" +
            " ORDER BY  " +
            "      CASE :sort WHEN 'Newest' THEN created END DESC," +
            "      CASE :sort WHEN 'Oldest' THEN created END ASC")
    fun all(sort: String): Flow<List<Entity>>
}

Meu modelo de visualização se parece com isto:

class EntityViewModel(application: Application) : AndroidViewModel(application) {
    private val entityDao = AppDatabase.getDatabase(context = application.baseContext).entityDao()
    var entities: Flow<List<Entity>> = entityDao.all()

    private val _selectedSortMode = MutableStateFlow(EntitySortMode.NEWEST)
    val selectedSortMode = _selectedSortMode.asStateFlow()

    private fun updateDatabaseQuery() {
        val sort = _selectedSortMode.value.string
        entities = entityDao.all(sort)
    }

    fun changeSorting(newSortMode: EntitySortMode) {
        _selectedSortMode.value = newSortMode
        updateDatabaseQuery()
    }
}

E meu composable é o seguinte:

@Composable
fun EntityView(viewModel: EntityViewModel) {
    val entities by viewModel.entities.collectAsStateWithLifecycle(initialValue = emptyList())

    LazyColumn {
        items(
            entities,
            key = {
                it.primaryKey
            }
        ) { entity ->
            Box(
                modifier = Modifier
                    .animateItem()
                    .clickable {}
             ) {
                 RowItem(entity)
            }
         }
    }
}

Simplifiquei o código para as partes relevantes. Recuperar e exibir dados do banco de dados funciona corretamente, o problema é que alterar a ordem de classificação (chamando changeSorting) não resulta na recomposição do LazyColumn. Os itens na lista são os mesmos, mas a ordem é diferente, e isso parece impedir que a recomposição ocorra.

Emitir

Estou (desesperadamente) tentando replicar essa configuração mlflow/minio no podman: https://github.com/minio/blog-assets/blob/main/mlflow-minio-setup/docker-compose.yml . O tutorial roda bem em uma VM usando docker-compose.

No podman, no entanto, eu simplesmente não consigo descobrir como executar o script para criar automaticamente um bucket no minio. Eu tentei muitas combinações possíveis para a opção --entrypoint, mas sempre falha com: Error: crun: executable file [/bin/sh,-c,/create_bucket.sh] not found in $PATH: No such file or directory: OCI runtime attempted to invoke a command that was not found...

Minha configuração

criar_bucket.sh:

#!/bin/sh
sleep 5;
/usr/bin/mc config host add mlflow_minio_storage http://mlflow_minio_storage:9000 "$MINIO_ACCESS_KEY" "$MINIO_SECRET_ACCESS_KEY" --api S3v4;
/usr/bin/mc ls mlflow_minio_storage | grep -q challenge || /usr/bin/mc mb mlflow_minio_storage/mlflow;
/usr/bin/mc policy download mlflow_minio_storage/mlflow;
exit 0;

Arquivo Docker:

FROM docker.io/minio/mc

COPY create_bucket.sh /create_bucket.sh
RUN chmod +x /create_bucket.sh

podman executado:

podman build -t minio_client:latest -f Containerfile
podman run \
--name=mlflow_minio_client \
--detach \
--secret=MINIO_ACCESS_KEY,type=env,target=MINIO_ACCESS_KEY \
--secret=MINIO_SECRET_ACCESS_KEY,type=env,target=MINIO_SECRET_ACCESS_KEY \
--net mlflow_net \
--network-alias mlflow_minio_client \
--restart always \
--requires mlflow_minio_storage \
--entrypoint ["/bin/sh","-c","/create_bucket.sh"] \
localhost/minio_client:latest

Exemplo mínimo

Mesmo esse caso simples resulta no mesmo erro. Estou entendendo algo errado aqui?

podman run \
--entrypoint ["/bin/sh","-c","/usr/bin/mc version"] \
docker.io/minio/mc:latest
>>> Error: crun: executable file `[/bin/sh,-c,/usr/bin/mc version]` not found in $PATH: No such file or directory: OCI runtime attempted to invoke a command that was not found

Tenho um gráfico mostrando os valores observados, uma previsão para cada valor e uma faixa atrás dele indicando a região de erro da previsão. Algo assim:

library(dplyr)
library(lubridate)
library(tidyr)
library(ggplot2)

set.seed(1234)

df <- economics %>%
  mutate(year = year(date)) %>%
  group_by(year) %>%
  summarise(pop = mean(pop, na.rm = TRUE)) %>%
  ungroup() %>%
  select(year, pop) %>%
  rowwise() %>%
  mutate(pred_factor = runif(1, 0, 2)) %>%
  mutate(limit_factor = runif(1, 0.5, 0.8)) %>%
  ungroup() %>%
  mutate(pred = pop * pred_factor) %>%
  mutate(limit_distance = pred * limit_factor) %>%
  mutate(lower_limit = pred - limit_distance) %>%
  mutate(upper_limit = pred + limit_distance) %>%
  select(year, pop, pred, lower_limit, upper_limit)

df %>%
  pivot_longer(cols = c(pop, pred), names_to = 'metric', values_to = 'value') %>%
  ggplot(aes(x = year, y = value, 
             ymin = lower_limit, ymax = upper_limit, 
             linetype = metric)) +
  geom_ribbon(fill = 'lightblue') +
  geom_line() +
  theme_bw()

No entanto, eu gostaria de separar a cor da fita em seu próprio item de legenda, para que eu possa rotulá-la separadamente. O melhor que eu consegui até agora é isto:

df %>%
  pivot_longer(cols = c(pop, pred), names_to = 'metric', values_to = 'value') %>%
  mutate(shading = 'predicted range') %>%
  ggplot(aes(x = year, y = value, 
             ymin = lower_limit, ymax = upper_limit, 
             linetype = metric, fill = shading)) +
  geom_ribbon() +
  geom_line() +
  scale_fill_manual(values = c('predicted range' = 'lightblue')) +
  theme_bw()

Mas por algum motivo essa abordagem cria um preenchimento cinza escuro atrás dos dois itens 'métricos' neste, tornando-os essencialmente ilegíveis. Existe uma maneira diferente de organizar esses dados e gráficos para que isso seja funcional?

Estou tentando integrar um jogo, construído com matter-js, no meu webapp SvelteKit existente, mas estou ficando perplexo sobre o porquê da gravidade não estar afetando o corpo circular que estou adicionando. O seguinte é o código typescript dentro do meu arquivo svelte:

onMount(async () => {
  const Matter = await import('matter-js');
  const canvas = document.getElementById("canvas")!

  const engine = Matter.Engine.create();

  const ball = Matter.Bodies.circle(100, 0, 10);
  Matter.Composite.add(engine.world, ball);
  Matter.Engine.update(engine);

  const render = Matter.Render.create({
    element: canvas,
    engine: engine,
    })
  Matter.Render.run(render);
  Matter.Runner.run(engine);
})

A bola está presa na posição inicial definida dentro do método circle(). Estou usando vite para o servidor dev local.

Então, estou tentando construir um artefato do meu programa JavaFX usando o IntelliJ Idea, mas quando tento executar o arquivo jar, continuo recebendoError: JavaFX runtime components are missing, and are required to run this application

Artefatos:

Bibliotecas:

Módulos:

Projeto:

Configuração de execução do arquivo principal:

Não tenho certeza do que estou perdendo aqui.

Estou tentando amostrar aleatoriamente n IDs para cada combinação de group_id e date em um Polars DataFrame. No entanto, notei que a função sample está produzindo o mesmo conjunto de IDs para cada date, não importa o grupo.

Como preciso definir uma semente para fins de replicação, acredito que o problema esteja ocorrendo porque o mesmo valor de semente está sendo aplicado em todas as combinações. Tentei resolver isso criando uma semente exclusiva para cada combinação gerando uma coluna "group_date_int" combinando group_id e date casted como Int64, mas encontrei o seguinte erro:

.sample(n=n_samples, shuffle=True, seed=pl.col("group_date_int"))
TypeError: argument 'seed': 'Expr' object cannot be interpreted as an integer

Para cada data, estou obtendo o mesmo conjunto de IDs, em vez de ter uma amostra aleatória diferente para cada combinação de group_id e data.

import polars as pl

df = pl.DataFrame(
    {
        "date": pl.date_range(
            pl.date(2010, 1, 1), pl.date(2025, 12, 1), "1mo", eager=True
        ).implode(),
        "group_id": [["bd01", "bd02", "bd03"]],
        "ids": [list(range(10))],
    }
).explode("date").explode("group_id").explode("ids")

# Parameters
n_samples = 3  # Number of random samples to pick for each group
SEED = 42  # The seed used for sampling

# Create `selected_samples` by sampling `n_samples` IDs per (group_id, date) combination
selected_samples = (
    df
    .group_by(['group_id', 'date'])
    .agg(
        pl.col("id")
        .sample(n=n_samples, shuffle=True, seed=SEED)  
        .alias("random_ids")
    )
    .explode("random_ids")
    .select(["group_id", "date", "random_ids"])
    .rename({"random_ids": "id"})
)

Além disso, tentei usar a função shuffle, mas os resultados são os mesmos: 1,6,5...1,6,5

┌──────────┬────────────┬─────┐
│ group_id ┆ date       ┆ id  │
│ ---      ┆ ---        ┆ --- │
│ str      ┆ str        ┆ i64 │
╞══════════╪════════════╪═════╡
│ bd01     ┆ 2025-07-01 ┆ 1   │
│ bd01     ┆ 2025-07-01 ┆ 6   │
│ bd01     ┆ 2025-07-01 ┆ 5   │
│ bd01     ┆ 2012-03-01 ┆ 1   │
│ bd01     ┆ 2012-03-01 ┆ 6   │
│ …        ┆ …          ┆ …   │
│ bd03     ┆ 2024-10-01 ┆ 6   │
│ bd03     ┆ 2024-10-01 ┆ 5   │
│ bd01     ┆ 2010-08-01 ┆ 1   │
│ bd01     ┆ 2010-08-01 ┆ 6   │
│ bd01     ┆ 2010-08-01 ┆ 5   │
└──────────┴────────────┴─────┘

Fui encaminhado para a seguinte questão nos comentários: Sample from each group in polars dataframe? , onde um problema semelhante foi levantado. No entanto, a solução não inclui uma semente, que é necessária para replicação.