All perguntas(coding)

Tenho o seguinte 3d- numpy.ndarray:

import numpy as np
X = np.array([
    [[0.0, 0.4, 0.6, 0.0, 0.0],
     [0.6, 0.0, 0.0, 0.0, 0.0],
     [0.4, 0.0, 0.0, 0.0, 0.0],
     [0.0, 0.6, 0.0, 1.0, 0.0],
     [0.0, 0.0, 0.4, 0.0, 1.0]],
    [[0.1, 0.5, 0.4, 0.0, 0.0],
     [0.6, 0.0, 0.0, 0.0, 0.0],
     [0.2, 0.0, 0.0, 0.0, 0.0],
     [0.1, 0.6, 0.0, 1.0, 0.0],
     [0.0, 0.0, 0.4, 0.0, 1.0]]
])

Quero uma nova matriz onde todas as linhas e colunas sejam descartadas onde a diagonal seja igual a 1.

idx = np.diag(X[0]) == 1          # for my implementation it is sufficient to look at X[0]

É importante ressaltar que X.shape[1] == X.shape[2], por isso, procuro usar a máscara da seguinte forma

Y = X[:, ~idx, ~idx]

O resultado acima retorna algo diferente da minha saída desejada:

 [[0.0, 0.4, 0.6],
  [0.6, 0.0, 0.0],
  [0.4, 0.0, 0.0]],
 [[0.1, 0.5, 0.4],
  [0.6, 0.0, 0.0],
  [0.2, 0.0, 0.0]]

Por favor, aconselhe

A pré-história era essa questão.

Revisei o validationMiddlewaremétodo assim:

export async function validationMiddleware<T extends object>(
  dtoClass: new () => T,
  validateTarget: string,
  req: Request,
  res: Response,
  next: NextFunction,
) {
  const dtoInstance = new dtoClass();
  const request = {
    body: req.body,
    query: req.query,
    params: req.params,
  };
  Object.assign(dtoInstance, request[validateTarget as keyof typeof request]);
  //request[validateTarget as keyof typeof request] = dtoInstance;
  const errors: ValidationError[] = await validate(dtoInstance, {
    forbidUnknownValues: true,
    whitelist: true,
    forbidNonWhitelisted: true,
  });
  if (errors.length > 0) {
    const validationErrors = errors.map((error) => ({
      [error.property]: Object.values(error.constraints || {}),
    }));
    const errorMessage = 'Invalid data provided';
    const errorResponse = { message: errorMessage, errors: validationErrors };
    return res.status(422).json(errorResponse);
  }
  next();
}

Então no roteador eu fiz isso:

userRoutes.post('/users/signup', (req, res, next) => {
  validationMiddleware(CreateUserDto, 'body', req, res, next);
  userController.signUp(req, res);
});

Mas se eu quiser postar nesta rota, recebo o erro Cannot set headers after they are sent to the client, se o objeto postado não tiver erro de validação. Se tiver algum, recebo os erros no Postman, mas também, neste caso, o método do controlador é executado.

Fiz uma pesquisa e entendi que envio a resposta duas vezes. Uma vez no validationMiddlewaremétodo e outra no signUpmétodo.

Para superar isso, tentei o seguinte:

• resolver o validateresultado para evitar ter uma função assíncrona e ter um fluxo síncrono
• introduza uma hasErrorvariável e retorne-a, e se não for verdadeira, chame o método do controlador
• se não houver erros, então em uma elsechamada de declaraçãonext()
• use returnapós enviar a resposta para encerrar o middleware

Sem sucesso. Qual é então o problema?

EDITAR

Agora, eu retrabalhei a função:

export function validationMiddleware<T extends object>(
  dtoClass: new () => T,
  validateTarget: string,
  req: Request,
  res: Response,
  next: NextFunction,
) {
  console.log('validation');
  let hasErrors = false;
  const dtoInstance = new dtoClass();
  const request = {
    body: req.body,
    query: req.query,
    params: req.params,
  };
  Object.assign(dtoInstance, request[validateTarget as keyof typeof request]);
  //request[validateTarget as keyof typeof request] = dtoInstance;
  //const errors: ValidationError[] = [];
  validate(dtoInstance, {
    forbidUnknownValues: true,
    whitelist: true,
    forbidNonWhitelisted: true,
  }).then((errors) => {
    if (errors.length > 0) {
      const validationErrors = errors.map((error) => ({
        [error.property]: Object.values(error.constraints || {}),
      }));
      const errorMessage = 'Invalid data provided';
      const errorResponse = { message: errorMessage, errors: validationErrors };
      res.status(422).json(errorResponse);
    } else {
      next();
    }
  });
}

Não há mais asynce await. Eu leio o valor da promessa e, se houver algum erro, envio para o cliente; caso contrário, vou para o próximo middleware (controlador).

Mas também neste caso, o controlador é executado. Se esta for uma maneira errada, como devo resolver? O que eu quero alcançar é o seguinte:

• validar a solicitação recebida
• se houver erros, envie para o cliente
• caso contrário, execute a lógica do controlador

Eu poderia escrever a lógica de validação no controlador, mas acho que isso não seria tão limpo, é por isso que estou tentando usar uma função separada fora do controlador.

O problema é que a validação (resolvendo a promessa) acontece após a invocação do método do controlador. Eu sei disso, mas como resolver isso? A validatefunção da class-validatorbiblioteca retorna um Promise.

EDIÇÃO 2:

Descobriu-se que a validatefunção também possui uma variante de sincronização. Então:

const dtoInstance = new dtoClass();
  const request = {
    body: req.body,
    query: req.query,
    params: req.params,
  };
  Object.assign(dtoInstance, request[validateTarget as keyof typeof request]);
  //request[validateTarget as keyof typeof request] = dtoInstance;
  const errors: ValidationError[] = validateSync(dtoInstance, {
    forbidUnknownValues: true,
    whitelist: true,
    forbidNonWhitelisted: true,
  });
  if (errors.length > 0) {
    console.log('validation');
    const validationErrors = errors.map((error) => ({
      [error.property]: Object.values(error.constraints || {}),
    }));
    const errorMessage = 'Invalid data provided';
    const errorResponse = { message: errorMessage, errors: validationErrors };
    res.status(422).json(errorResponse);
  }
  return errors.length > 0;

E no percurso:

userRoutes.post('/users/signup', (req, res, next) => {
  if (!validationMiddleware(CreateUserDto, 'body', req, res, next))
    userController.signUp(req, res);
});

Agora funciona como esperado.

Estou tentando espelhar um repositório público pertencente à minha organização no GitHub (sou administrador da organização) para um repositório privado na minha conta pessoal. Fiz o seguinte:

• Criei um token de acesso granular com muitas permissões (fiquei um pouco desesperado) Read and Write access to Dependabot alerts, actions, actions variables, administration, attestations api, code, codespaces, codespaces lifecycle admin, codespaces secrets, commit statuses, dependabot secrets, deployments, discussions, environments, issues, merge queues, pages, pull requests, repository advisories, repository custom properties, repository hooks, secret scanning alerts, secrets, security events, and workflows
• Verifiquei 100x se o token tem acesso ao meu repositório privado pessoal
• Fluxos de trabalho habilitados para execução no meu repositório pessoal:

Mas continuo vendo o erro:

> Run git remote add private
> https://***@github.com/xxxx.git
> origin    https://github.com/yyyy (fetch)
> origin    https://github.com/yyyy (push)
> private   https://***@github.com/xxxx.git
> (fetch)
> private   https://***@github.com/xxxx.git
> (push) remote: Permission to xxxx.git
> denied to github-actions[bot]. fatal: unable to access
> 'https://github.com/xxxx/': The
> requested URL returned error: 403 Error: Process completed with exit
> code 128.

Minha ação no github é definida da seguinte forma:

name: Mirror Repository

on:
  push:
    branches: [main]
  workflow_dispatch: # Allows manual triggering of the workflow

jobs:
  mirror:
    runs-on: ubuntu-latest
    permissions:
      contents: write
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4
        with:
          fetch-depth: 0 # Fetch all history for all branches and tags

      - name: Push to private mirror
        env:
          PERSONAL_ACCESS_TOKEN: ${{ secrets.PERSONAL_ACCESS_TOKEN }}
        run: |
          git remote add private https://${{ secrets.PERSONAL_ACCESS_TOKEN }}@github.com/xxxx.git
          # Debug: List remotes to verify
          git remote -v
          git push private --force --all
          git push private --force --tags

Alguém pode me ajudar? Estou sem ideias.

O código a seguir parece estar com estouro. Por quê?

#include <chrono>
#include <iostream>

int main() {
    auto now = std::chrono::steady_clock::now();
    auto low = std::chrono::steady_clock::time_point::min();
    auto elapsed = std::chrono::duration_cast<std::chrono::seconds>(now - low).count();
    std::cout << elapsed << "\n";
    return 0;
}

Eu esperaria lowque fosse o ponto de tempo mais antigo. É assim que entendo a descrição "Valor de retorno" em https://en.cppreference.com/w/cpp/chrono/time_point/min .

Portanto, qualquer outro valor, por exemplo now, deve ser maior e a diferença now - lowdeve ser uma duração positiva. A menos que, de alguma forma, transborde em algum lugar? É um bug (improvável; todos os principais compiladores parecem ter esse problema )? É algum erro meu de compreensão de chrono que está errado?

Como posso consertar isso?

Contexto: Tenho uma lista de elementos. Alguns elementos estão sendo usados ​​ativamente, outros têm um registro de data e hora que indica quando foram usados ​​pela última vez. Periodicamente, os registros de data e hora são verificados se forem muito antigos e, nesse caso, os elementos com esses registros de data e hora antigos são removidos da lista.

Um usuário pode invocar manualmente uma operação de limpeza. Ela define todos os registros de data e hora existentes para lowque, quando a próxima verificação for realizada, todos esses elementos sejam removidos.

Posso definir lowum now - reasonableBigButNotTooBigvalor para que funcione, mas pensei que std::chrono::steady_clock::time_point::minseria mais idiomático.

Quero capturar a exceção de acesso negado do Spring Boot quando, por exemplo, um usuário estiver prestes a acessar uma página de um administrador.

Eu tenho esse manipulador de exceção no meu GlobalExceptionHandler (@ControllerAdvice)

    @ExceptionHandler(AccessDeniedException.class)
    @ResponseStatus(HttpStatus.FORBIDDEN)
    public String handleAccessDenied(AccessDeniedException e, Model model) {
        model.addAttribute("errorMessage", e.getMessage());
        return "error";
    }

Tentei usar um CustomAccessDeniedHandler:

@Component
public class CustomAccessDeniedHandler implements AccessDeniedHandler {
    @Override
    public void handle(HttpServletRequest request, HttpServletResponse response, AccessDeniedException accessDeniedException) throws IOException, ServletException {
        throw accessDeniedException;
    }
}

e no meu SecurityConfig adicionei isso ao meu filterChain:

.exceptionHandling(eh -> eh.accessDeniedHandler(customAccessDeniedHandler))

E agora recebo um acesso negado no meu terminal: org.springframework.security.authorization.AuthorizationDeniedException: Acesso negado

Quero capturar isso com meu GlobalExceptionHandler (tentei usar AuthorizationDeniedException em ExceptionHandler)

Nota: Eu não uso JWT

O que estou perdendo?

def index(request):
    game_data = GameDataEntry()
    update_progress = ProjectProgressEntry()
    work_hours = WorkHoursEntry()
    if request.method == "GET":
        form = RecordSearchForm(data=request.GET)
        if form.is_game is True:
            query = request.GET.get('entry_date')
            object_list = game_data.objects.filter(entry_date=query)
            return HttpResponse(object_list, content_type='text/plain')
        if form.is_work is True:
            query = request.GET.get('entry_date')
            object_list = work_hours.objects.filter(entry_date=query)
            return HttpResponse(object_list, content_type='text/plain')
        if form.is_Progress is True:
            query = request.GET.get('entry_date')
            object_list = update_progress.objects.filter(entry_date=query)
            return HttpResponse(object_list, content_type='text/plain')
    else:
        form = RecordSearchForm()

    return render(request, 'index.html', context={'form': form})

Esta é minha classe Form

class RecordSearchForm(forms.Form):
    is_Progress = forms.BooleanField(widget=forms.CheckboxInput(
        attrs={'class': 'form-check-input', "id": "is_progress_update", "type": 'checkbox'}))
    is_game = forms.BooleanField(widget=forms.CheckboxInput(
        attrs={'class': 'form-check-input', "id": "is_game_update", "type": "checkbox"}))
    is_work = forms.BooleanField(widget=forms.CheckboxInput(
        attrs={'class': 'form-check-input', "id": "is_work_entry", "type": "checkbox"}))
    game_name = forms.ModelChoiceField(widget=forms.Select(
        attrs={'class': 'form-control', "id": "game_name"}), queryset=Games.objects.all())
    entry_date = forms.DateField(widget=forms.DateInput(
        attrs={'class': 'form-control', "id": "date_entry", "type": "date"}))

Estou tentando criar uma função de pesquisa para obter os registros com base na data da entrada para os modelos que são desenvolvimento de jogos, atualizações concluídas ou horas de trabalho, mas está dizendo que is_game não é um atributo do meu formulário, mas está claramente lá. Alguém pode me dizer o que estou fazendo errado ou o que perdi?

Eu tenho a seguinte expressão do Azure Data Factory

@{pipeline().parameters.Zone}/@{pipeline().parameters.Classification}/@{pipeline().parameters.Area}/@{pipeline().parameters.Domain}/@{pipeline().parameters.TableName}

Como adicionar a extensão .csv ao TableName? Tentei o seguinte:

@{pipeline().parameters.Zone}/@{pipeline().parameters.Classification}
/@{pipeline().parameters.Area}/@{pipeline().parameters.Domain}
/@{pipeline().parameters.TableName,'.csv'}

Mas recebi o erro:

Parameter TableName,'.csv' was not found

Estou tentando criar uma ScrollView com um LazyVStack onde dois cabeçalhos são fixados no topo. Também deve funcionar dentro de um NavigationStack usando o modo de exibição grande para o título. Ambos os cabeçalhos devem estar dentro da ScrollView para que a animação do título grande funcione durante a rolagem (passando do título grande para o pequeno ao rolar para baixo).

Foi isso que eu tentei:

struct StickyHeaderHeightKey: PreferenceKey {
    static var defaultValue: CGFloat = 0
    static func reduce(value: inout CGFloat, nextValue: () -> CGFloat) {
        value = nextValue()
    }
}

struct ContentView: View {
    let scrollCoordinateSpace = "scroll"
    @State private var headerHeight: CGFloat = 0
    
    var body: some View {
        NavigationStack {
            ScrollView {
                VStack(alignment: .leading, spacing: 0) {
                    GeometryReader { geometry in
                        let frame = geometry.frame(in: .named(scrollCoordinateSpace))
                        let offset = max(0, -frame.minY)
                        
                        HStack {
                            Image(systemName: "pin.fill")
                            Text("Sticky Header")
                                .font(.headline)
                            Spacer()
                        }
                        .padding()
                        .background(Color.red.opacity(0.8))
                        .offset(y: offset)
                        .background(
                            GeometryReader { proxy in
                                Color.clear
                                    .preference(key: StickyHeaderHeightKey.self, value: proxy.size.height)
                            }
                        )
                    }
                    .frame(height: headerHeight)
                    .zIndex(1)

                    // --- Main Content ---
                    LazyVStack(spacing: 0, pinnedViews: .sectionHeaders) {
                        ForEach(0..<50) { index in
                            Section {
                                VStack(alignment: .leading, spacing: 0) {
                                    Text("Content \(index + 1)")
                                        .padding(.vertical, 10)
                                        .padding(.horizontal)
                                    Text("Content \(index + 1)")
                                        .padding(.vertical, 10)
                                        .padding(.horizontal)
                                    Text("Content \(index + 1)")
                                        .padding(.vertical, 10)
                                        .padding(.horizontal)
                                }
                                .background(Color.green.opacity(0.5))
                            } header: {
                                VStack(spacing: 0) {
                                    Text("Header")
                                        .padding(.vertical, 6)
                                        .padding(.horizontal)
                                        .background(Color.blue.opacity(0.5))
                                }
                                .frame(maxWidth: .infinity, alignment: .leading)
                                .background(Color.blue.opacity(0.5))
                            }
                        }
                    }
                }
            }
            .coordinateSpace(name: scrollCoordinateSpace)
            .navigationTitle("Large Title")
            .navigationBarTitleDisplayMode(.large)
            .onPreferenceChange(StickyHeaderHeightKey.self) { value in
                headerHeight = value
            }
        }
    }
}

O problema que estou enfrentando é que os cabeçalhos da seção LazyVStack são sempre fixados na posição mais alta do ScrollView e não abaixo do cabeçalho vermelho fixo.

Estou tentando fazer esse código funcionar:

#include <iostream> // For general input and output
#include <Windows.h> // Windows API for interacting with windows processes
#include <TlHelp32.h> // For getting snapshots

int main()
{
    /*
        Get the process ID to attach later
    */

    DWORD gameProcID = -1; // Variable to hold the process ID, has to be a DWORD because the windows API wants it that way. Starts as -1 (which is invald) so it is known if the process wasn't found
    HANDLE procSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS , 0); // Creates a "snapshot" of the current processes (Essentially a list of the processes)
    
    // Creates a placeholder process entry, that will hold each process for checking
    PROCESSENTRY32 currentProc;
    currentProc.dwSize = sizeof(PROCESSENTRY32); // Has to have it's "sizeof" member set, or else the loop fails. 

    // Loops through each process in the snapshot until it finds Winquake.exe
    if (Process32First(procSnap, &currentProc)) { // Starts by getting the first process
        do {
            if (!_wcsicmp(currentProc.szExeFile, L"Winquake.exe")) { // Checks if the process is Winquake, using a Wide Character String Compare function
                // If found, update the variable and break out the loop
                gameProcID = currentProc.th32ProcessID;
                break;
            }
        } while (Process32Next(procSnap, &currentProc)); // While there are still more processes, keep checking
    }
    CloseHandle(procSnap); // Close the snapshot. Good memory management :)

    // If it can't find the process, print and then close
    if (gameProcID == -1) {
        std::cout << "Couldn't find process" << std::endl;
        exit(1);
    }

    /*
        Get the module inside the found process (Quite similar to finding the process)
    */

    uintptr_t gameBaseAddr = -1; // Variable to hold the base memory address of the module we want to find, Starts as -1 (which is invalid) so it is known if the module wasn't found
    HANDLE modSnap = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE | TH32CS_SNAPMODULE32, gameProcID); // Creates a snapshot of all the modules inside the process

    // Creates a placeholder module entry, that will hold each module for checking
    MODULEENTRY32 currentMod;
    currentMod.dwSize = sizeof(currentMod); // Has to have it's "sizeof" member set, or else the loop fails.

    // Loops through each module in the snapshot until it finds Winquake.exe
    if (Module32First(modSnap, &currentMod)) { // Starts by getting the first module
        do {
            if (!_wcsicmp(currentMod.szModule, L"Winquake.exe")) { // Checks if the module is Winquake, using a Wide Character String Compare fucntion
                // If found, update the variable and break out the loop
                gameBaseAddr = (uintptr_t)currentMod.modBaseAddr;
            }
        } while (Module32Next(modSnap, &currentMod)); // While there are still more modules, keep checking
    }
    CloseHandle(modSnap); // Close the snapshot. Good memory management

    // If it can't find the module, print and then close
    if (gameBaseAddr == -1) {
        std::cout << "Couldn't find module inside game. Perhaps you have the wrong 'Winquake.exe' executable" << std::endl;
        exit(1);
    }

    // The final handle for the game process
    HANDLE gameProc = OpenProcess(PROCESS_ALL_ACCESS, NULL, gameProcID); // Opens a handle to attach to the Winquake process and module. With full access rights

}

Ele não lança uma exceção, mas se você definir um ponto de interrupção na linha 56 do código, poderá ver no depurador que o modBaseAddrcampo do currentModobjeto contém a string modBaseAddr 0x00007ffac7c00000 <Error reading string characters.>.

Se você tentar enviar o valor deste campo para o console usando std::cout, uma exceção será lançada:

Uma exceção foi lançada em 0x00007FF9FAA77CC1 (ucrtbased.dll) em ProjectName.exe: 0xC0000005: Violação de acesso ao ler 0x00007FF7EF6C0000.

Tentei obter dados de diferentes jogos.

Meu Visual Studio está sendo executado como administrador e executa o projeto como administrador. Também tentei executar o .exearquivo da pasta "debug" como administrador.

Nenhuma delas afetou o problema.

Também não consegui encontrar nada sobre meu problema na Internet.

Eu esperava que o modBaseAddrcampo do currentModobjeto contivesse o endereço base do módulo.

se alguma coisa, todos os outros campos deste objeto contêm dados corretos.

Imagine que você tem o seguinte trecho de código:

struct S
{
  S() = default(); 
  S(S const&){std::cout << "copy ctor" << '\n';};
  S& operator=(S const&) { std::cout << "copy assignment" << '\n'; return *this; }
  ~S();
};

S createS(){return s{};}

int main()
{
  S s{}; 

  s = createS(); 
}

Embora seja contra a regra dos cinco, o que acontece na atribuição de sna main()função? createS()retorna um valor-r. Assim, o compilador procurará um operador de atribuição de movimento e, como ele não é gerado e excluído automaticamente, retornará ao operador de atribuição de cópia. No entanto, um valor-r semanticamente não se vincula a uma operação de cópia, pois não possui um identificador e não pode ser reutilizado (pelo que entendi).

Minha pergunta é: como o operador de atribuição lida com essa situação e distingue entre valor r e valor l?