All perguntas(coding)

Estou trabalhando com resultados de simulação armazenados em uma estrutura defaultdict profundamente aninhada. Essa estrutura (data_to_save) mistura tipos padrão do Python (listas, ints, floats, None) com arrays NumPy.

Preciso salvar toda esta estrutura data_to_save em um arquivo JSON. Como json.dump não consegue lidar com arrays NumPy nativamente, e estou usando o NumPy 2.0 (onde os aliases de tipo mais antigos foram removidos), escrevi uma função recursiva personalizada, make_json_serializable, para converter tipos NumPy e lidar com possíveis problemas como np.nan:

import numpy as np
import json
from collections import defaultdict

# Custom converter for NumPy types and NaNs
def make_json_serializable(obj):
    if isinstance(obj, np.ndarray): return obj.tolist()
    # Important: Handle defaultdict specifically before dict
    if isinstance(obj, defaultdict): return {k: make_json_serializable(v) for k, v in obj.items()}
    if isinstance(obj, dict): return {k: make_json_serializable(v) for k, v in obj.items()}
    if isinstance(obj, list): return [make_json_serializable(i) for i in obj]
    # Check base Python types first
    if isinstance(obj, (int, float, bool, complex, str, type(None))): return obj
    # Check abstract NumPy types (NumPy 2.0+)
    if isinstance(obj, np.integer): return int(obj)
    if isinstance(obj, np.floating): return float(obj) if not np.isnan(obj) else None # Convert NaN to None for JSON compatibility
    if isinstance(obj, np.complexfloating): return {'real': float(obj.real), 'imag': float(obj.imag)}
    if isinstance(obj, np.bool_): return bool(obj)
    if isinstance(obj, (np.void)): return None
    # Fallback if type not recognized
    # print(f"Warning: Type {type(obj)} not explicitly handled. Passing as is.") # Optional debug
    return obj
# --- END CONVERTER ---

# Example of the nested structure (simplified)
data_to_save = defaultdict(lambda: defaultdict(lambda: defaultdict(lambda: defaultdict(dict))))
data_to_save['category_A']['size_X']['config_1']['setting_alpha']['parameter_grid'] = np.linspace(0, 1, 5)
data_to_save['category_A']['size_X']['config_1']['setting_alpha']['metric_array_1'] = np.array([0.1, 0.2, 0.5, 0.8, 1.0])
data_to_save['category_A']['size_X']['config_1']['setting_alpha']['num_valid_entries'] = 5
data_to_save['category_A']['size_X']['config_1']['setting_alpha']['distribution_data'] = {
    '0.5': {'size_values': [1, 2, 3], 'normalized_counts': np.array([0.5, 0.3, 0.2]), 'source_count': 5}
}
# ... structure can be deeply nested with more arrays ...

Minha tentativa de salvar esses dados resulta em um TypeError:

# Current (failing) saving code:
output_filename = "output_data.json"
try:
    # PROBLEM: This tries to dump the raw structure with NumPy arrays using the standard encoder
    temp_dict_structure = json.loads(json.dumps(data_to_save)) # <-- FAILS HERE with TypeError

    # The custom converter is intended to run here, but never gets called due to the previous line's error
    serializable_data = make_json_serializable(temp_dict_structure)

    with open(output_filename, "w") as f:
        json.dump(serializable_data, f, indent=2, allow_nan=False) # NaNs should be None by converter
    print(f"Data saved to: {output_filename}")

except TypeError as e_json:
    print(f"ERROR during JSON processing: {e_json}") # Output: ERROR during JSON processing: Object of type ndarray is not JSON serializable
except Exception as e_save:
    print(f"ERROR saving file: {e_save}")

A mensagem de erro TypeError: Object of type ndarray is not JSON serializable aponta para a chamada json.dumps(data_to_save). Isso confirma que o codificador JSON padrão encontra um array NumPy antes que minha função make_json_serializable tenha a chance de convertê-lo. O comando intermediário json.loads(json.dumps(...)) provavelmente foi uma tentativa de converter defaultdicts, mas ele aciona o TypeError primeiro.

Pergunta:

Como posso aplicar corretamente minha função de conversão personalizada (make_json_serializable) a toda a estrutura defaultdict aninhada (data_to_save) antes de passá-la para json.dump? O objetivo é garantir que todos os arrays NumPy aninhados e tipos numéricos especiais sejam convertidos em listas básicas do Python, ints, floats ou None, resolvendo o TypeError.

Tenho dados de um estudo de intervenção com 4 grupos experimentais (Grupo) e três pontos de medição (Tempo). Realizei uma análise de perfil e transição, que resultou em 4 perfis (Perfil). Criei um diagrama aluvial mostrando as transições dos perfis entre os pontos de medição para cada grupo experimental.

library(ggplot2)
library(ggalluvial)
library(dplyr)
library(tidyr)

df <- tibble(id = 1:400, group = sample(1:4, size = 400, replace = TRUE)) |>
crossing(time = 1:3) |>
mutate(profile = sample(1:4, size = n(), replace = TRUE))|>
mutate(profile = as.character(profile), time = as.character(time))


ggplot(df, aes(x = time, stratum = profile, alluvium = id, fill = profile, label = profile)) +
    scale_fill_brewer(type = "seq", palette = "BrBG") +
    geom_flow() +
    geom_stratum() +
    labs(x = "Time", y = "N") +
    facet_wrap('group', labeller = label_both)

Como os 4 grupos não têm o mesmo tamanho amostral, gostaria de plotar os tamanhos relativos dos estratos em vez dos absolutos, de modo que todos os perfis para cada ponto no tempo totalizem 100%. Não sei como fazer isso. Usar o atributo de peso não funcionou.

Estou trabalhando em um trecho de código R para calcular a diversidade em um conjunto de dados de taxonomias de fungos. O tutorial que estou seguindo tem um trecho de código que soma cada linha, o que não está funcionando porque a primeira coluna (que exibe os números da OTU) não é numérica, mas sim de caracteres. Aqui está o trecho de código:

# make relative abundances
dat_relab = as.data.frame(sapply(dat_clean, FUN = function(x){x / sum(x)}))
rownames(dat_relab) = rownames(dat_clean)

# Remove low abundant ASVs, i.e. for which total relative abundance is lower than 0.01%
dat_relab$relab = rowSums(dat_relab) # adds column with total number of reads per ASV
keep01 = which(dat_relab$relab > 0.0001) # selects which ASVs fit the cut-off
dat_relab01 = dat_relab[keep01, -26] # outputs filtered table, and removes added column with number reads

# Select the ASVs with relative abundance higher than 0.01% from the ASV table with read number for the subsequent analysis
dat_clean2 = dat_clean[rownames(dat_relab01), colnames(dat_relab01)]

O código para na 2ª linha e fornece o seguinte erro: Erro em sum(x): 'tipo' (caractere) de argumento inválido

Eu entendo logicamente qual é o problema aqui; a primeira coluna dos dados não é numérica e não será somada. Meu problema é entender como corrigir isso e por que não está dando errado no tutorial (que tem os dados formatados da mesma forma).

Estou criando um programa em Python para testar um servidor web que estou construindo. Uso httpx e queria usar http2 também, para poder enviar requisições http versão 2. A única maneira que encontrei de instalá-lo é pip install httpx[http2], mas o pip não está funcionando no WSL ( error: externally-managed-environment). Eu resolvi isso com https, python3-pip install httpxmas python3-pip install httpx[http2]parece que não funciona, nem com nenhuma outra variante que tentei.

Para esclarecer, tanto meu servidor web quanto meu programa python estão sendo executados em WSL.

O erro que me fez olhar para o http2 foi:

Error: Using http2=True, but the 'h2' package is not installed. Make sure to install httpx using `pip install httpx[http2]`.

Quero que minha especificação JSON do OpenAPI use Camel Case em todos os parâmetros de string de consulta para minhas rotas. Até agora, a única maneira de fazer isso funcionar foi usando [FromQuery(Name = "camelCase")]em todas as minhas propriedades. Existe uma maneira melhor de definir essa configuração em algum lugar para que eu não precise fazer essas alterações em todas as propriedades da minha API?

public class UsageQueryParams
{
    [FromQuery(Name = "contractType")] public ContractType? ContractType { get; set; }
    [FromQuery(Name = "limit")] public long? Limit { get; set; }
}

Estou trabalhando em um projeto Angular 19 usando componentes independentes e o Angular Material .
Quero usar ícones FontAwesome ( @fortawesome/angular-fontawesome) junto com componentes do Angular Material, como mat-icon, mas não tenho certeza sobre a maneira correta de integrá-los.

Aqui está o que fiz até agora:

/// <reference types="@angular/localize" />

import { bootstrapApplication } from '@angular/platform-browser';
import { appConfig } from './app/app.config';
import { AppComponent } from './app/app.component';
import { FaIconLibrary } from '@fortawesome/angular-fontawesome';

Eu instalei os pacotes necessários:

npm install @fortawesome/fontawesome-svg-core
npm install @fortawesome/free-solid-svg-icons
npm install @fortawesome/angular-fontawesome

No entanto, não tenho certeza:

• Como registrar corretamente os ícones FaIconLibraryem uma configuração autônoma .
• Como usar os <fa-icon>componentes internos do Angular Material, como mat-list, mat-toolbar, etc.
• Se há uma maneira limpa de usar os ícones do FontAwesome oumat-icon se <fa-icon>eles devem ser usados ​​separadamente.

Qualquer exemplo ou prática recomendada seria apreciada!

Em Programação Paralela e Concorrente em Haskell , de Simon Marlow, o capítulo 7 começa na página 125 com este exemplo,

import Control.Concurrent
import Control.Monad
import System.IO

main :: IO ()
main = do
  hSetBuffering stdout NoBuffering
  _ <- forkIO (replicateM_ 100000 (putChar 'A'))
  replicateM_ 100000 (putChar 'B')

que tem uma saída como esta

BBBBBBBABABABAAAAAAA

(que, aliás, é o resultado que realmente obtive ao alterar 100000para 10o snippet acima e executar o programa).

No final do capítulo, página 140, é feito o seguinte comentário (grifo meu):

[…] Este é um exemplo da garantia de imparcialidade na prática. […]. Portanto, isso leva à alternância perfeita entre as duas threads. A única maneira de o padrão de alternância ser quebrado é se uma thread for desescalonada enquanto não estiver segurando o MVar. De fato, isso acontece de tempos em tempos como resultado da preempção, e ocasionalmente vemos uma longa sequência de uma única letra na saída.

Com base no resultado que mostrei, sim, consigo ver que a alternância está quebrada, mas não entendi bem a explicação acima. Não há nem um MVarno primeiro exemplo.

Por exemplo, se eu tiver uma tabela mais ou menos assim:

Quero conseguir pesquisar "Cobre" e obter seus dois índices correspondentes (P2, R2). Preciso conseguir obtê-los separadamente, então provavelmente uma fórmula para obter o "P" e outra para obter o "R". Obter os índices numéricos e alfabéticos no Planilhas Google e, em seguida, obter os "nomes" dos índices de lá provavelmente seria a melhor aposta, pelo que sei.

Tentei usar vlookup, hlookup, query, match, index e qualquer outra coisa que eu pudesse encontrar online, mesmo que vagamente relacionada, mas sem sucesso. O problema que encontrei com todas essas ferramentas é que elas só querem pesquisar uma linha ou coluna por vez, o que significa que, na melhor das hipóteses, eu precisaria de pelo menos 20 fórmulas diferentes para pesquisar cada linha, uma por uma.

Obrigado a todos pela ajuda!

Contexto:
Tenho um componente Angular que renderiza um campo de preenchimento automático do Angular Material . O campo tem três opções, e cada opção contém um namee um id. Quando uma opção é selecionada, seu namecampo deve ser exibido no campo.

Problema:
Quando uma opção é selecionada inicialmente, o namecampo é exibido conforme o esperado. No entanto, quando a mesma opção é selecionada novamente, mesmo já estando selecionada, o idcampo exibe o campo. O campo nameexibe o campo da opção selecionada, e não o campo id.

Pergunta
Como isso pode ser corrigido para que, independentemente de quantas vezes uma opção seja selecionada, o namecampo seja sempre exibido, e não o idcampo?

StackBlitz

TS

import { CommonModule } from '@angular/common';
import { ChangeDetectionStrategy, Component } from '@angular/core';
import { FormsModule } from '@angular/forms';
import {
  MatAutocompleteModule,
  MatAutocompleteSelectedEvent,
} from '@angular/material/autocomplete';
import { MatInputModule } from '@angular/material/input';

interface Item {
  id: string;
  name: string;
}

@Component({
  selector: 'app-autocomplete',
  standalone: true,
  templateUrl: './autocomplete.component.html',
  styleUrls: ['./autocomplete.component.css'],
  changeDetection: ChangeDetectionStrategy.OnPush,
  imports: [CommonModule, FormsModule, MatAutocompleteModule, MatInputModule],
})
export class AutocompleteComponent {
  options: Item[] = [
    { id: '1', name: 'Item One' },
    { id: '2', name: 'Item Two' },
    { id: '3', name: 'Item Three' },
  ];
  name: string = '';
  id: string = '';
  placeholder: string = 'Select an option';

  resetField() {
    this.name = '';
  }

  selectionChange(e: MatAutocompleteSelectedEvent) {
    this.name = e.option.viewValue;
    console.log(e.option.viewValue); // name
    console.log(e.option.value); // id
  }
}

HTML

<mat-form-field>
  <mat-label>{{ placeholder }}</mat-label>
  <input
    #assetInput
    type="text"
    [placeholder]="placeholder"
    matInput
    [(ngModel)]="name"
    [matAutocomplete]="auto"
  />
  <mat-autocomplete
    #auto="matAutocomplete"
    (optionSelected)="selectionChange($event)"
  >
    <mat-option *ngFor="let option of options" [value]="option.id">
      {{ option.name }}
    </mat-option>
  </mat-autocomplete>
</mat-form-field>

Em Programação Paralela e Concorrente em Haskell , de Simon Marlow, nas páginas 133 e 134, o seguinte código é mostrado:

type Name        = String
type PhoneNumber = String
type PhoneBook   = Map Name PhoneNumber

newtype PhoneBookState = PhoneBookState (MVar PhoneBook)

lookup :: PhoneBookState -> Name -> IO (Maybe PhoneNumber)
lookup (PhoneBookState m) name = do
  book <- takeMVar m
  putMVar m book
  return (Map.lookup name book)

E na página seguinte, algumas observações. A parte final do segundo parágrafo me intriga um pouco. Aqui está a primeira metade do parágrafo:

Usar estruturas de dados imutáveis ​​em um wrapper mutável traz outros benefícios. Observe que, na lookupoperação, simplesmente capturamos o valor atual do estado e, em seguida, a Map.lookupoperação complexa ocorre fora da sequência takeMVar/ putMVar. Isso é bom para a concorrência, pois significa que o bloqueio é mantido apenas por um período muito curto.

Isso é bastante claro para mim, no sentido de que entendo que isso takeMVarcoloca o bloqueio e putMVaro libera imediatamente, de modo que os acessos simultâneos subsequentes ao PhoneBookStatenão sejam mais prejudicados. Ao mesmo tempo, também vejo que outras mutações do MVarsão possíveis, então, quando o tempo lookupretorna com um Just smth, esse (name, smth)par pode ter sido removido do mapa (ou, se retornou Nothing, alguns (name, smth)podem ter sido adicionados ao mapa).

Entretanto, não entendi o que a seguinte parte do parágrafo tenta transmitir:

Isso só é possível porque o valor do estado é imutável. Se a estrutura de dados fosse mutável, teríamos que manter o bloqueio enquanto operávamos nela.⁵

---

⁵. A outra opção é usar um algoritmo sem bloqueios, que é extremamente complexo e difícil de acertar.

O que isso significa? O autor está se referindo ao caso que Mapexpôs alguma API a uma mutação? Isso nem é possível, a menos que estejamos em IO, certo? Ou ele está se referindo a mutações realizadas no mconteúdo de (por outras threads após putMVara liberação do bloqueio) que de alguma forma afetaram booko conteúdo de ?