All perguntas(coding)

Na maioria das vezes não consigo fazer uma solicitação para o seguinte site:

https://www.adondevivir.com/proyectos-etapa-pre-venta-en-construccion.html

library(rvest);library(tibble);library(httr2)

base_url <- "https://www.adondevivir.com/proyectos-etapa-pre-venta-en-construccion.html"

parsed_base_url <- base_url |> 
  read_html()  # This works sometimes and I get the underlying html

# THIS NEVER WORKS
pagina_parsed <- base_url |> 
  request() |> 
  req_user_agent(
    "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36"
  ) |> 
  req_headers(
    Referer = "https://www.adondevivir.com/",
    Accept = "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8",
    `Accept-Language` = "es-419,es;q=0.6",
    `Accept-Encoding` = "gzip, deflate, br, zstd",
    `Cache-Control` = "max-age=0",
    `Sec-Ch-Ua` = '"Brave";v="125", "Chromium";v="125", "Not.A/Brand";v="24"',
    Priority = "u=0, i"
  ) |> 
  req_perform()

Por que não consigo fazer solicitações à página na maioria das vezes (nem mencionar que ela não funciona com httr2 com os cabeçalhos fornecidos acima)? Existe uma maneira de superar esse "problema" httr2? Isso tem a ver com cookies ou com a forma como a página está se protegendo de ser copiada?

Acho que poderia repetir a solicitação várias vezes até que funcionasse, mas acho que não aprenderia muito sobre o motivo pelo qual ela não funciona.

Quando o usuário pressiona o botão para mostrar o retângulo, a animação de deslocamento do texto não deve ser substituída por .smooth(duration: 0.25) mas, em vez disso, continuar sua animação linear de 50 segundos.

Abaixo está o exemplo completo.

struct ContentView: View {
    @State private var showingRect = false
    var body: some View {
        VStack {
            Button("Show Rect") {
                withAnimation(.smooth(duration: 0.25)) {
                    showingRect.toggle()
                }
            }
            
            TextView()
            
            if showingRect {
                Rectangle()
                    .foregroundStyle(.blue)
                    .frame(width: 100, height: 100)
            }
            
        }
        .padding()
    }
}

struct TextView: View {
    @State private var animate = false
    
    var body: some View {
        Text("This is a very long text. Yeah, it is very very long.")
            .lineLimit(1)
            .offset(x: animate ? -300 : 0)
            .onAppear {
                withAnimation(.linear(duration: 50)) {
                    animate = true
                }
            }
    }
}

como posso selecionar o último item da lista na pathscoluna após aplicar a função str.split("/")?

dataNpaths = pl.scan_csv("test_data/file*.csv", has_header=True, include_file_paths = "paths").collect()
dataNpaths.with_columns(pl.col("paths").str.split("/").alias("paths"))

>>> dataNpaths.with_columns(pl.col("paths").str.split("/").alias("paths"))
shape: (30, 5)
┌──────────┬──────────┬──────────┬──────────┬────────────────────────────┐
│ Column1  ┆ Column2  ┆ Column3  ┆ Column4  ┆ paths                      │
│ ---      ┆ ---      ┆ ---      ┆ ---      ┆ ---                        │
│ f64      ┆ f64      ┆ f64      ┆ f64      ┆ list[str]                  │
╞══════════╪══════════╪══════════╪══════════╪════════════════════════════╡
│ 0.603847 ┆ 0.509877 ┆ 0.091579 ┆ 0.43821  ┆ ["test_data", "file1.csv"] │
│ 0.572299 ┆ 0.817647 ┆ 0.087951 ┆ 0.397217 ┆ ["test_data", "file1.csv"] │
│ 0.886123 ┆ 0.159805 ┆ 0.766246 ┆ 0.083915 ┆ ["test_data", "file1.csv"] │
│ 0.142208 ┆ 0.413847 ┆ 0.043408 ┆ 0.147779 ┆ ["test_data", "file1.csv"] │
│ 0.105215 ┆ 0.924754 ┆ 0.309823 ┆ 0.724407 ┆ ["test_data", "file1.csv"] │
│ …        ┆ …        ┆ …        ┆ …        ┆ …                          │
│ 0.381675 ┆ 0.849887 ┆ 0.498281 ┆ 0.733085 ┆ ["test_data", "file3.csv"] │
│ 0.697427 ┆ 0.950464 ┆ 0.999596 ┆ 0.645253 ┆ ["test_data", "file3.csv"] │
│ 0.49979  ┆ 0.172414 ┆ 0.679287 ┆ 0.091804 ┆ ["test_data", "file3.csv"] │
│ 0.668585 ┆ 0.640259 ┆ 0.932463 ┆ 0.579558 ┆ ["test_data", "file3.csv"] │
│ 0.077462 ┆ 0.802565 ┆ 0.966791 ┆ 0.29297  ┆ ["test_data", "file3.csv"] │

mas nenhuma dessas abordagens funcionou

dataNpaths.with_columns(pl.col("paths").str.split("/")[-1].alias("paths"))
dataNpaths.with_columns(pl.col("paths").str.split("/",-1).alias("paths"))

Tenho uma textura que quero usar como luz radiante indireta.

Há um problema que quando eu faço uma amostra do mip mais baixo desta textura, o resultado fica assim:

mas na verdade deveria ficar assim:

Eu uso um shader de computação para gerar dados de brilho, mas para o caso de depuração você pode usar um cubemap normal com mipmaps gerados por hardware ( glGenerateTextureMipmap) ou carregá-lo de um arquivo. O resultado será o mesmo - tradução difícil.

Sombreador de vértice:

#version 460 core

layout(location = 0) in vec3 a_position;
layout(location = 1) in vec3 a_normal;

//per instance
layout(location = 2) in vec4 a_modelToWorld0;
layout(location = 3) in vec4 a_modelToWorld1;
layout(location = 4) in vec4 a_modelToWorld2;
layout(location = 5) in vec4 a_modelToWorld3;

layout(location = 0) out vec3 v_worldPosition;
layout(location = 1) out vec3 v_worldNormal;

layout(std140, binding = 0) uniform PerFrame
{
    mat4 cameraModel;
    mat4 viewProjection;
} u_frame;

void main()
{
    mat4 model = mat4(a_modelToWorld0, a_modelToWorld1, a_modelToWorld2, a_modelToWorld3);
    
    vec4 worldPosition = model * vec4(a_position, 1.0f);

    v_worldPosition = worldPosition.xyz;
    v_worldNormal = mat3(model) * a_normal;

    gl_Position = u_frame.viewProjection * worldPosition;
}

sombreador de pixels:

#version 460 core

layout(location = 0) out vec4 f_color;

layout(location = 0) in vec3 v_worldPosition;
layout(location = 1) in vec3 v_worldNormal;

layout(std140, binding = 0) uniform PerFrame
{
    mat4 cameraModel;
    mat4 viewProjection;
} u_frame;

layout(binding = 1) uniform samplerCube u_indirectRadiance;

void main()
{
    vec3 normal = normalize(v_worldNormal);
    vec3 viewDirection = normalize(u_frame.cameraModel[3].xyz - v_worldPosition);
    vec3 reflectionDir = reflect(-viewDirection, normal);

    vec3 color = textureLod(u_indirectRadiance, reflectionDir, 10.0f).rgb;

    f_color = vec4(color, 1.0f);
}

Fiz algumas depurações e verifiquei , normale esses vetores parecem corretos: viewDirectionreflectionDir

Comparei esses valores com meu aplicativo DX11, que me fornece luz de brilho indireto correto e tudo parece igual.

Quanto ao problema em si, não se trata dos dados do cubemap porque eu os verifiquei. Tem valores corretos.

O problema é a forma como é amostrado.

código que cria o mapa do cubo radiante e o amostrador

GLuint sampler;
glCreateSamplers(1, &sampler);

glSamplerParameteri(sampler, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glSamplerParameteri(sampler, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
                            
glSamplerParameteri(sampler, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glSamplerParameteri(sampler, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glSamplerParameteri(sampler, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);

GLuint texture;
glCreateTextures(GL_TEXTURE_CUBE_MAP, 1, &texture);
glTextureStorage2D(texture, 11, GL_RGBA32F, 1024, 1024);

//here you can load a texture from a file
//eg. dds
/*

DirectX::TexMetadata meta;
DirectX::ScratchImage image;
//assuming that radianceCubemap.dds is 1024x1024, cubemap and has mipmaps generated correctly
DirectX::LoadFromDDSFile("assets/radianceCubemap.dds", DirectX::DDS_FLAGS_NONE, &meta, image);

GLuint target = GL_TEXTURE_CUBE_MAP;
GLuint format = GL_COMPRESSED_RGB_S3TC_DXT1_EXT; //assuming format is DXGI_FORMAT_BC1_UNORM, but this is just an example

for (std::size_t level = 0; level < meta.mipLevels; ++level) {
    for (std::size_t face = 0; face < meta.arraySize; ++face) {
        const DirectX::Image* img = image.GetImage(level, face, 0);
        if (img) {
            glCompressedTextureSubImage3D(texture, level, 0, 0, face, img->width, img->height, 1, format, img->slicePitch, img->pixels);
        }
    }
}
*/

/*
or you can do whatever, it does not matter, just make sure it's a 1024x1024 cubemap with 11 mips
*/

meu mapa de cubo:

como você pode ver está tudo correto

O que há de errado com meu código? Como posso consertar isso?

Fiz um teste simples de desempenho em python 3.12.0contra python 3.13.0b3compilado com um --disable-gilsinalizador. O programa executa cálculos de uma sequência de Fibonacci usando ThreadPoolExecutorou ProcessPoolExecutor. Os documentos sobre o PEP que introduzem o GIL desativado dizem que há um pouco de sobrecarga principalmente devido à contagem de referência tendenciosa seguida de bloqueio por objeto ( https://peps.python.org/pep-0703/#performance ). Mas diz que a sobrecarga no benchmark pyperformance está em torno de 5-8%. Meu benchmark simples mostra uma diferença significativa no desempenho. Na verdade, o python 3.13 sem GIL utiliza todas as CPUs com a, ThreadPoolExecutormas é muito mais lento que o python 3.12 com GIL. Com base na utilização da CPU e no tempo decorrido, podemos concluir que com o python 3.13 realizamos várias vezes mais ciclos de clock em comparação com o 3.12.

Código do programa:

from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
import datetime
from functools import partial
import sys
import logging
import multiprocessing

logging.basicConfig(
    format='%(levelname)s: %(message)s',
)
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)
cpus = multiprocessing.cpu_count()
pool_executor = ProcessPoolExecutor if len(sys.argv) > 1 and sys.argv[1] == '1' else ThreadPoolExecutor
python_version_str = f'{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}'
logger.info(f'Executor={pool_executor.__name__}, python={python_version_str}, cpus={cpus}')


def fibonacci(n: int) -> int:
    if n < 0:
        raise ValueError("Incorrect input")
    elif n == 0:
        return 0
    elif n == 1 or n == 2:
        return 1
    else:
        return fibonacci(n-1) + fibonacci(n-2)

start = datetime.datetime.now()

with pool_executor(8) as executor:
    for task_id in range(30):
        executor.submit(partial(fibonacci, 30))

    executor.shutdown(wait=True)

end = datetime.datetime.now()
elapsed = end - start
logger.info(f'Elapsed: {elapsed.total_seconds():.2f} seconds')

Resultado dos testes:

# TEST Linux 5.15.0-58-generic, Ubuntu 20.04.6 LTS

INFO: Executor=ThreadPoolExecutor, python=3.12.0, cpus=2
INFO: Elapsed: 10.54 seconds

INFO: Executor=ProcessPoolExecutor, python=3.12.0, cpus=2
INFO: Elapsed: 4.33 seconds

INFO: Executor=ThreadPoolExecutor, python=3.13.0b3, cpus=2
INFO: Elapsed: 22.48 seconds

INFO: Executor=ProcessPoolExecutor, python=3.13.0b3, cpus=2
INFO: Elapsed: 22.03 seconds

Alguém pode explicar por que sinto tanta diferença ao comparar a sobrecarga com a do benchmark pyperformance?

EDITAR 1

1. Eu tentei pool_executor(cpus)em vez de pool_executor(8)-> ainda obtive resultados semelhantes.
2. Assisti a este vídeo https://www.youtube.com/watch?v=zWPe_CUR4yU e executei o seguinte teste: https://github.com/ArjanCodes/examples/blob/main/2024/gil/main.py

Resultados:

Version of python: 3.12.0a7 (main, Oct  8 2023, 12:41:37) [GCC 9.4.0]
GIL cannot be disabled
Single-threaded: 78498 primes in 6.67 seconds
Threaded: 78498 primes in 7.89 seconds
Multiprocessed: 78498 primes in 5.85 seconds

Version of python: 3.13.0b3 experimental free-threading build (heads/3.13.0b3:7b413952e8, Jul 27 2024, 11:19:31) [GCC 9.4.0]
GIL is disabled
Single-threaded: 78498 primes in 61.42 seconds
Threaded: 78498 primes in 32.29 seconds
Multiprocessed: 78498 primes in 39.85 seconds

então, mais um teste em minha máquina quando terminamos com um desempenho várias vezes mais lento. Por falar nisso. No vídeo podemos ver resultados de sobrecarga semelhantes aos descritos no PEP.

EDITAR 2

Como sugeriu @ekhumoro, configurei a compilação com os seguintes sinalizadores:
./configure --disable-gil --enable-optimizations
e parece que o --enable-optimizationssinalizador faz uma diferença significativa nos benchmarks considerados. A build anterior foi feita com a seguinte configuração:
./configure --with-pydebug --disable-gil.

Resultados dos testes:

Referência de Fibonacci:

INFO: Executor=ThreadPoolExecutor, python=3.12.0, cpus=2
INFO: Elapsed: 10.25 seconds

INFO: Executor=ProcessPoolExecutor, python=3.12.0, cpus=2
INFO: Elapsed: 4.27 seconds

INFO: Executor=ThreadPoolExecutor, python=3.13.0, cpus=2
INFO: Elapsed: 6.94 seconds

INFO: Executor=ProcessPoolExecutor, python=3.13.0, cpus=2
INFO: Elapsed: 6.94 seconds

Referência de números primos:

Version of python: 3.12.0a7 (main, Oct  8 2023, 12:41:37) [GCC 9.4.0]
GIL cannot be disabled
Single-threaded: 78498 primes in 5.77 seconds
Threaded: 78498 primes in 7.21 seconds
Multiprocessed: 78498 primes in 3.23 seconds

Version of python: 3.13.0b3 experimental free-threading build (heads/3.13.0b3:7b413952e8, Aug  3 2024, 14:47:48) [GCC 9.4.0]
GIL is disabled
Single-threaded: 78498 primes in 7.99 seconds
Threaded: 78498 primes in 4.17 seconds
Multiprocessed: 78498 primes in 4.40 seconds

Portanto, o ganho geral da mudança do multiprocessamento python 3.12 para o multithreading python 3.12 no-gil é uma economia significativa de memória (temos apenas um único processo).

Quando comparamos a sobrecarga da CPU para a máquina com apenas 2 núcleos:

[Fibonacci] Multi-threading Python 3.13 contra multiprocessamento Python 3.12: (6,94 - 4,27) / 4,27 * 100% ~ = 63% de sobrecarga

[Números primos] Multithreading Python 3.13 versus multiprocessamento Python 3.12: (4,17 - 3,23) / 3,23 * 100% ~= 29% de sobrecarga

Como tornar uma variável float complexa ou dupla complexa dependendo da entrada do usuário? Estou tentando traçar o conjunto de Mandelbrot e tenho o mesmo código longo para float e double, mas em alguns casos float não é preciso o suficiente e double é muito lento. Estou executando em uma calculadora de baixo desempenho, então float leva menos de 1 segundo e double leva pelo menos 5 segundos. Gostaria de permitir que o usuário escolhesse precisão em vez de velocidade ou velocidade em vez de precisão. Eu gostaria de obter algo assim:

int user_input;
scanf("%d", &user_input);

switch (user_input) {
      case 0:
          float z;
          float c;
          break;
      case 1:
          double z;
          double c;
          break;
}
for(int i=0;i<1920;i++){
    for(int j=0;j<1080;j++){
        z=0.0+0.0*I;
        c=(i+j*I)/Zoom
}}

Resultado esperado: se o usuário digitar 0, todos os cálculos serão realizados usando floats, e se o usuário digitar 1, os cálculos serão realizados usando doubles.

Mas isso gera um erro: tipos conflitantes para 'z'; tem 'double', declaração anterior de 'z' com tipo 'float'.

Algo assim é possível em C?

Tentei criar duas variáveis ​​diferentes para float e double, mas alterá-las em todo o código (tenho muito mais código) seria longo e tedioso.

Tenho um valor Json abaixo em string groupsjasontext e gosto de analisar id, member.value, role.value usando JsonConverter.ParseJson. Como eu vou fazer isso ? Tentei mostrar via messagebox o campo id e estou recebendo o erro Type Mismatch

    Set JsonData = JsonConverter.ParseJson(groupsjasontext)
    tempName = JsonData("id")(0)
    MsgBox (tempName)

    {
  "schemas": [
    "urn:ietf:params:scim:api:messages:2.0:ListResponse"
  ],
  "totalResults": 3,
  "startIndex": 1,
  "itemsPerPage": 3,
  "Resources": [
    {
      "schemas": [
        "urn:ietf:params:scim:schemas:core:2.0:Group",
        "urn:sap:params:scim:schemas:extension:sac:2.0:group-custom-parameters"
      ],
      "id": "d3094970-ce7e-4794-b9e2-f84817b7c820",
      "meta": {
        "resourceType": "Group",
        "created": "2024-05-21T17:53:06.808Z",
        "lastModified": "2024-05-21T17:53:06.808Z",
        "location": "/api/v1/scim2/Groups/d3094970-ce7e-4794-b9e2-f84817b7c820"
      },
      "displayName": "AHI_VW_ALL_REGION",
      "urn:sap:params:scim:schemas:extension:sac:2.0:group-custom-parameters": {
        "description": "View Mode ALL REGION"
      }
    },
    {
      "schemas": [
        "urn:ietf:params:scim:schemas:core:2.0:Group",
        "urn:sap:params:scim:schemas:extension:sac:2.0:group-roles",
        "urn:sap:params:scim:schemas:extension:sac:2.0:group-custom-parameters"
      ],
      "id": "bef561ee-5a1e-420e-a1e\n4-4f624c96af6e",
      "meta": {
        "resourceType": "Group",
        "created": "2024-07-25T14:17:53.215Z",
        "lastModified": "2024-08-01T14:31:29.632Z",
        "location": "/api/v1/scim2/Groups/bef561ee-5a1e-420e-a1e4-4f624c96af6e"
      },
      "displayName": "TEAM_TEST",
      "members": [
        {
          "value": "f27dcbb9-df9a-46b2-b23a-3b35d5a8bdff",
          "type": "User",
          "display": "Test_FirstName1 TEST_Familyname1",
          "$ref": "/api/v1/scim2/Users/f27dcbb9-df9a-46b2-b23a-3b35d5a8bdff"
        }
      ],
      "urn:sap:params:scim:schemas:extension:sac:2.0:group-roles": {
        "roles": [
          {
            "value": "PROFILE:t.4:VIEW_USER",
            "display": "VIEW_USER"
          }
        ]
      },
      "urn:sap:params:scim:schemas:extension:sac:2.0:group-custom-parameters": {
        "description": "Team Test"
      }
    },
    {
      "schemas": [
        "urn:ietf:params:scim:schemas:core:2.0:Group",
        "urn:sap:params:scim:schemas:extension:sac:2.0:group-custom-parameters"
      ],
      "id": "1edd9227-c8de-486e-93f6-69396524c792",
      "meta": {
        "resourceType": "Group",
        "created": "2024-05-21T17:51:49.808Z",
        "lastModified": "2024-05-21T17:53:06.121Z",
        "location": "/api/v1/scim2/Groups/1edd9227-c8de-486e-93f6-69396524c792"
      },
      "displayName": "AHI_VW_EURAM\n",
      "urn:sap:params:scim:schemas:extension:sac:2.0:group-custom-parameters": {
        "description": "View mode EURAM"
      }
    }
  ]
}

No Python 3.12, temos aliases de tipo como este:

Python 3.12.4+ (heads/3.12:99bc8589f0, Jul 27 2024, 11:20:07) [GCC 12.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> type S = str
>>> S
S

Por esta sintaxe presumi que, a partir de agora, a typepalavra é considerada uma palavra-chave, mas não é:

>>> type = 2
>>> 

e também:

>>> import keyword
>>> keyword.iskeyword('type')
False

Estou fazendo um aplicativo de planejamento de casamento onde os usuários podem adicionar seus convidados a determinadas mesas, grupos, etc...

Estou tentando listar todos os grupos e dentro de cada grupo mostrar todos os convidados desse grupo (na mesma página like e acordeão)

Parece fácil e funciona, mas ao usar o DebugBar, posso ver que ele está fazendo duas consultas exatamente iguais e não consigo descobrir o porquê.

Um Evento pode ter muitos grupos e cada grupo pode ter muitos convidados.

$event = Event::find($id_event);
$event->load('group');
$event->group->load([
    "guest" => function ($q) {
       return $q->paginate(10);
    }
]);

O resultado:

Editar

Esqueci de mencionar que se eu adicionar outras relações a isso, elas também serão duplicadas.

$event->group->load([
    'guest.plusone',
    "guest" => function ($q) {
       $q->paginate(10);
    }
]);

Editar 2

Ao tentar fazer o que você sugeriu, descobri o que causa isso, mas ainda não sei por quê.

Quando tento fazer o que você sugeriu, obtenho o mesmo resultado

$event->load(['group', 'group.guest' => function ($query) {
    $query->paginate(10);
}]);

Mas se eu remover o retorno de chamada da paginação, receberei apenas uma consulta. Isso é normal? Eu sei que a paginação faz uma consulta extra para obter os resultados totais, mas neste caso está fazendo 3 consultas e 2 delas são exatamente iguais

Uma função do PowerShell precisa executar um .exe cuja localização não é conhecida em tempo de design porque faz parte de um pacote NuGet. Se eu executá-lo usando Invoke-Expressiono PSScriptAnalyzer gera um aviso me dizendo para encontrar um método alternativo, no entanto, se eu executá-lo usando, &não recebo nenhum aviso.

Esta é a função que faz parte de um módulo para executar testes de unidade e gerar um relatório de cobertura de código em uma máquina onde o IDE instalado não suporta cobertura de código (por exemplo, Visual Studio Community Edition).

function Invoke-ReportGenerator {
    param (
        [Parameter(Mandatory=$true)][string]$testProjectFolder,
        [Parameter(Mandatory=$true)][string]$testProjectName,
        [Parameter(Mandatory=$true)][string]$assemblyUnderTest,
        [Parameter(Mandatory=$false)][string]$coverageXmlFilename,
        [Parameter(Mandatory=$false)][string]$reportGeneratorPath
    )

    if ([System.String]::IsNullOrWhiteSpace($coverageXmlFilename)) {
        $coverageXmlFilename = "coverage.opencover.xml";
    }

    $absoluteOutputPath = [System.IO.Path]::Combine($testProjectFolder, "CodeCoverage");
    $absoluteInputPath = [System.IO.Path]::Combine($testProjectFolder, $coverageXmlFilename);
    $argumentArray = @(
        "-reports:$absoluteInputPath",
        "-targetDir:$absoluteOutputPath",
        "-title:$testProjectName",
        "-assemblyFilters:$assemblyUnderTest"
    );
    if ([System.String]::IsNullOrWhiteSpace($reportGeneratorPath)) {
        $reportGeneratorPath = "$env:USERPROFILE\.nuget\packages\reportgenerator\5.2.4\tools\net6.0\reportgenerator.exe ";
    }

    $reportGeneratorCommand = "$reportGeneratorPath $argumentArray";
    Invoke-Expression $reportGeneratorCommand;
}

Este é o aviso levantado pelo PSScriptAnalyzer

Invoke-Expression is used. Please remove Invoke-Expression from script and find other options instead.

Os documentos da Microsoft dizem para evitar o uso de Invoke-Expression

Considere cuidadosamente as implicações de segurança. Quando uma string de uma fonte não confiável, como a entrada do usuário, é passada diretamente para Invoke-Expression, comandos arbitrários podem ser executados. Sempre considere primeiro uma solução diferente, mais robusta e segura.

Se eu mudar a linha

Invoke-Expression $reportGeneratorCommand;

para

& $reportGeneratorCommand;

Então o aviso desaparece. Mas certamente isso é tão vulnerável a um ataque de injeção de código quanto Invoke-Expression? o que estou perdendo?

Editar: substituir as 2 últimas linhas da função pelas & $reportGeneratorPath @argumentArraysugeridas por @MathiasRJessen simplifica um pouco a função, mas acredito que ainda a deixa vulnerável.