All perguntas(coding)

Tenho um arquivo de configuração que (propositalmente) contém alguns aliases indefinidos:

base:
  foo: *args_foo
  bar: *args_bar
  fuz: fuz_val
  buz: buz_val

Enquanto isso, tenho um cli que recebe --foo e --bar como argumentos, onde --foo pode ser especificado várias vezes. Acabo com um dict parecido com:

args = {}
args["foo"] = ["foo_val_1", "foo_val_2", "foo_val_3"]
args["bar"] = "bar_val"

Gostaria de despejar os args para yaml, mas com âncoras personalizadas para cada chave em arg. Algo assim:

args:
  foo: &args_foo
  - foo_val_1
  - foo_val_2
  - foo_val_3
  bar: &args_bar "bar_val"

Eu poderia escrever meu próprio código para gerar o doc, mas eu preferiria de alguma forma dizer ao ruamel.yaml para lidar com a adição das âncoras antes da serialização. A questão é, isso é possível e, se sim, como?

A intenção é então concatenar os dois arquivos assim:

args:
  foo: &args_foo
  - foo_val_1
  - foo_val_2
  - foo_val_3
  bar: &args_bar "bar_val"
base:
  foo: *args_foo
  bar: *args_bar
  fuz: fuz_val
  buz: buz_val

e extrair "base" como a configuração final após carregar o documento concatenado.

Em python, assim

df = pl.DataFrame({"foo": ["a", "a", "b"], "bar": [1, 2, 3]})
for name, data in df.group_by("foo"):  
    print(name)
    print(data)

saída:

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

Como fazer o mesmo em Rust?

Estou procurando um desmontador de comprimento de instrução ARM64 bem minimalista, para que eu possa percorrer algumas instruções de uma função.
Preciso de uma função autônoma sem muitas dependências, porque preciso dela para um driver de kernel.

Para x64 eu estava usando https://github.com/gh-nomad/length-disassembler/blob/master/ldisasm.cpp mas não consigo encontrar algo parecido para AArch64. Há algumas bibliotecas de desmontagem completas, mas elas vêm com uma tonelada de código-fonte e dependências de user land.

Eu nem preciso de suporte para nenhum dos conjuntos de instruções de extensão como SVE

Estou trabalhando em um projeto de montagem web Blazor com vários projetos em uma única solução. No entanto, quando tento construir a solução usando dotnet build, recebo o seguinte erro:

erro NETSDK1082: Não havia nenhum pacote de tempo de execução para Microsoft.AspNetCore.App disponível para o RuntimeIdentifier especificado 'browser-wasm'.

Estrutura do projeto ( .sln)

Tenho quatro projetos na minha solução:

1. RazorClassLibrary(componentes compartilhados)
2. TraningBlazorAPIProject(API da Web do ASP.NET Core)
3. TraningBlazorProject(Servidor Blazor, atua como o ponto de entrada principal)
4. TraningBlazorProject.Client(Frontend de montagem web Blazor)

TraningBlazorProject.Client.csproj(Montagem web Blazor):

<Project Sdk="Microsoft.NET.Sdk.BlazorWebAssembly">
    <PropertyGroup>
        <TargetFramework>net9.0</TargetFramework>
        <RuntimeIdentifier>browser-wasm</RuntimeIdentifier>
        <ImplicitUsings>enable</ImplicitUsings>
        <UseBlazorWebAssembly>true</UseBlazorWebAssembly>
        <Nullable>enable</Nullable>
        <StaticWebAssetProjectMode>Default</StaticWebAssetProjectMode>
    </PropertyGroup>

   <ItemGroup>
        <PackageReference Include="Microsoft.AspNetCore.Components.WebAssembly" Version="9.0.3" />
        <PackageReference Include="Microsoft.AspNetCore.JsonPatch" Version="9.0.3" />
        <PackageReference Include="Microsoft.AspNetCore.Mvc.NewtonsoftJson" Version="9.0.3" />
    </ItemGroup>
</Project>

TraningBlazorProject.csproj(Servidor Blazor)

<Project Sdk="Microsoft.NET.Sdk.Web">
  <PropertyGroup>
    <TargetFramework>net9.0</TargetFramework>
    <Nullable>enable</Nullable>
    <ImplicitUsings>enable</ImplicitUsings>
  </PropertyGroup>

  <ItemGroup>
    <ProjectReference Include="..\RazorClassLibrary\RazorClassLibrary.csproj" />
    <ProjectReference Include="..\TraningBlazorProject.Client\TraningBlazorProject.Client.csproj" />
    <PackageReference Include="Microsoft.AspNetCore.Components.WebAssembly.Server" Version="9.0.3" />
  </ItemGroup>
</Project>

Detalhes do erro

TraningBlazorProject.Client falhou com 1 erro(s)
C:\Program Files\dotnet\sdk\9.0.202\Sdks\Microsoft.NET.Sdk\targets\Microsoft.NET.Sdk.FrameworkReferenceResolution.targets(512,5): erro NETSDK1082: Não havia nenhum pacote de tempo de execução para Microsoft.AspNetCore.App disponível para o RuntimeIdentifier especificado 'browser-wasm'.

Etapas de solução de problemas que tentei (mas não funcionaram):

1. Verificado FrameworkReferenceem TraningBlazorProject.Client.csproj. Verificado que Microsoft.AspNetCore.Appnão é referenciado no projeto de montagem da web.

2. Removido ProjectReferencede TraningBlazorProject.csprojpara TraningBlazorProject.Client.csproj.

   Como o assembly web do Blazor não deve ser referenciado diretamente pelo servidor Blazor, eu o removi temporariamente e tentei compilar novamente, mas o erro persistiu.

3. Reinstalei cargas de trabalho .NET
   Executadas:

   dotnet workload uninstall wasm-tools
   dotnet workload install wasm-tools
   dotnet workload repair
   

   Mas ainda estou recebendo o mesmo erro.

4. Caches NuGet limpos e pacotes restaurados

   dotnet nuget locals all --clear
   dotnet restore
   

   Ainda sem sorte.

5. Excluiu bine objpastas e reconstruiu o projeto

   rd /s /q bin obj
   dotnet clean
   dotnet restore
   dotnet build
   

   O erro permanece.

Questões :

• Por que o Blazor web assembly (browser-wasm) está tentando referenciar o Microsoft.AspNetCore.App, que é apenas para o servidor Blazor?

• Existe um conflito entre TraningBlazorProject.Client(Blazor WASM) e TraningBlazorProject(servidor Blazor)?

• Como posso estruturar adequadamente a solução para evitar esse erro?

Criei alguns jogos de console simples em Python ( Oyna Project ) e tirei screenshots de cada jogo para mostrá-los no arquivo README.md . Eu queria exibir essas imagens em um formato de tabela no GitHub e no PyPI.

No GitHub, tudo parece bem — as imagens estão bem alinhadas e seus tamanhos são consistentes. Mas quando eu envio esta biblioteca (Oyna) para o PyPI , os tamanhos das imagens parecem desiguais e desbalanceados. O problema é que as imagens em si não são do mesmo tamanho e, no PyPI, algumas imagens parecem muito menores ou maiores do que outras, fazendo com que a tabela pareça bagunçada.

Tentei ajustar o tamanho das imagens usando tags HTML e sintaxe Markdown, mas nada parece funcionar corretamente no PyPI.

Como posso fazer com que as imagens sejam exibidas de forma consistente e uniforme no PyPI, assim como no GitHub, mesmo que seus tamanhos originais sejam diferentes?

Meu código para exibir a tabela:

<table>
   <tr>
      <td><a href="https://github.com/kamyarmg/oyna/tree/main/src/oyna/sudoku/"> Sudoku </a> </br><img src="https://raw.githubusercontent.com/kamyarmg/oyna/refs/heads/main/docs/images/sudoku.png" alt="Sudoku" style="width:250px;"/> </td>
      <td><a href="https://github.com/kamyarmg/oyna/tree/main/src/oyna/twenty_forty_eight_2048/">2048</a> </br><img src="https://raw.githubusercontent.com/kamyarmg/oyna/refs/heads/main/docs/images/2048.png" alt="2048" style="width:250px;"/> </td>
      <td><a href="https://github.com/kamyarmg/oyna/tree/main/src/oyna/matching/">Matching</a> </br><img src="https://raw.githubusercontent.com/kamyarmg/oyna/refs/heads/main/docs/images/matching.png" alt="Matching" style="width:250px;"/> </td>
   </tr>
</table>

Tabela de imagens do Github README.md:

Tabela de imagens Pypi:

Tenho um dataframe com os dados abaixo.

A ser alcançado : 2 novas colunas, a primeira com a soma cumulativa de Qtd até a Data/Hora em cada linha quando a Tag não for igual a 2, a segunda com a soma cumulativa de Qtd até a Data/Hora em cada linha quando a Tag for igual a 2. Abaixo está o resultado que estou procurando.

Estou procurando um método, mas parece que não estou conseguindo. Posso obter ajuda para conseguir?

Obrigado,

Quando dou ponteiros para estruturas de extensão a serem preenchidas quando chamo vkGetPhysicalDeviceFeatures, o sinalizador rayTracingPipeline é 1, o que significa que ele deve ser suportado, e praticamente todos os sinalizadores em VkPhysicalDeviceRayTracingPipelineFeaturesKHR são definidos como 1. No entanto, quando crio o dispositivo lógico, recebo o erro de validação:

pCreateInfo->pNext inclui um ponteiro para um VkPhysicalDeviceRayTracingPipelineFeaturesKHR, mas ao criar o VkDevice, a extensão pai (VK_KHR_ray_tracing_pipeline) não foi incluída em ppEnabledExtensionNames.

Então, justo, parece que eu tenho que habilitar o VK_KHR_RAY_TRACING_PIPELINE_EXTENSION_NAME na lista de extensões habilitadas ao criar o dispositivo lógico. Então eu faço isso, mas então eu recebo:

Retorno de chamada da camada de validação Vulkan: loader_validate_device_extensions: A extensão do dispositivo VK_KHR_ray_tracing_pipeline não é suportada pelo dispositivo físico selecionado ou pelas camadas habilitadas.

Retorno de chamada da camada de validação Vulkan: vkCreateDevice: Falha ao validar extensões na lista

Quando verifico o nome da extensão com vkEnumerateDeviceExtensionProperties, ele não está na lista. Estou usando uma Radeon RX570.

Estou escrevendo um bootloader simples (e, espero que em breve, um sistema operacional). Tenho feito progressos, mas esta parte está me deixando um pouco perplexo.

Estou gravando este sistema operacional e bootloader em uma imagem de disco, que consiste em:

1. Um setor de inicialização MBR e um bootloader de primeiro estágio
2. Uma área reservada de 32kb para o bootloader de segundo estágio
3. Uma partição FAT32 que contém o sistema operacional ekernel.bin

Meu objetivo é carregar kernel.bin na memória e pular para ele, e para fazer isso preciso percorrer as tabelas FAT.

Muita lógica envolvida na leitura da partição FAT32 requer valores de 32 bits (como muitos valores BPB)

Como estou essencialmente bloqueado no modo real por enquanto, não tenho certeza de como lidar com esses números de 32 bits ao executar cálculos como multiplicação. Sei que posso usar registradores de 32 bits usando o prefixo de tamanho do operando e/ou prefixo de tamanho do endereço, mas não posso realmente usar operações aritméticas neles de forma significativa.

Exemplo

Aqui está uma seção do assembly que armazena valores importantes do BPB:

BPB_info:

    ; BPB info from the FAT32 boot sector
    BPB_NumFATs: db 0 ; Number of FATs (1 byte)
    BPB_FATSz32: dd 0 ; Size of each FAT in sectors (4 bytes)
    BPB_RootClus: dd 0 ; First cluster of the root directory (4 bytes)
    BPB_SecPerClus: db 0 ; Sectors per cluster (1 byte)
    BPB_RsvdSecCnt: dw 0 ; Reserved sectors count (2 bytes)

    ; Calculated values used in the bootloader
    FAT_root_dir_start: dq 0 ; Start of the root directory in sectors (calculated)
    FAT_lba: dq 0 ; Logical block address of the FAT tables (calculated)

Para calcular FAT_root_dir_start, devo usar a seguinte fórmula:

BPB_RsvdSecCnt + ((BPB_RootClus - 2) * BPB_SecPerClus)

Mas como BPB_RootClusé uma doubleword (32 bits), não tenho certeza de como realizar essa operação.

Qualquer conselho seria apreciado! Estou no caminho certo? Devo abordar isso de forma completamente diferente? Talvez mudar para o modo protegido? Não tenho certeza.

Estou com dificuldades para entender a definição de templates. Meu entendimento básico é que as definições de templates permitem tornar o tipo de dados para retorno ou argumentos como genérico. Ou seja, um argumento de template é um tipo de dados para o qual o compilador instancia e vincula em tempo de compilação,

Mas não consigo entender definições complexas como as abaixo:

#include <iostream>
#include <type_traits>

template <unsigned n>
struct factorial : std::integral_constant<int,n * factorial<n-1>::value> {};

template <>
struct factorial<0> : std::integral_constant<int,1> {};

int main() {
  std::cout << factorial<5>::value;  // constexpr (no calculations on runtime)
  return 0;
}

onde

template <class T, T v>
struct integral_constant {
  static constexpr T value = v;
  typedef T value_type;
  typedef integral_constant<T,v> type;
  constexpr operator T() { return v; }
};

Saída:

120

É realmente difícil visualizar como os modelos são instanciados:

template <int,5 * factorial<5-1>::value>
struct integral_constant {
  static constexpr int value = 5 * factorial<5-1>::value;
  typedef int value_type;
  typedef integral_constant<5 * factorial<5-1>::value> type;
  constexpr operator int() { return 5 * factorial<5-1>::value; }
};

Tenho uma string muito longa que estou construindo em Haskell

let str = "(\"" ++ (int_list_to_string (printed ctx) "") ++ "\",\"" ++ (int_list_to_string (stack ctx) "") ++ "\")"

Isso é feio, e eu tenho tentado colocar as coisas em linhas separadas, mas recebo um erro quando faço algo como

let str = "(\"" 
    ++ (int_list_to_string (printed ctx) "")
    ++ ...

aparentemente independente do recuo que coloquei antes de cada linha.

Como posso escrever uma concatenação de string longa em linhas separadas? Estou usando GHC se isso for importante.