Início / coding / 问题

All perguntas(coding)

Martin Hope
and
Asked: 2025-01-01 09:25:07 +0800 CST
  • 9

Estou testando GETrequisições básicas sob o requestsmódulo. Estou usando requests.Sessionpara criar uma instância de sessão que é passada posteriormente para a função.

Estou zombando das chamadas de função. Eu corrigi a session.getchamada dentro da função, mas recebo o seguinte erro:

AssertionError: chamada get('https://example-name/v1/0001') não encontrada

Imagino que não tenha corrigido o local corretamente, mas não tenho certeza de onde exatamente estou errando.

principal.py

import requests

base_url = "https://example-name/v1/"

session = requests.Session()

def fetch_data_with_session(session, base_url, endpoint):
    response = session.get(base_url + endpoint)  
    return response.json()

teste_main.py

import unittest
from requests import Session
from main import fetch_data_with_session
from unittest.mock import Mock, patch


class TestingGet(unittest.TestCase):
    
    @patch.object(Session, 'get')
    def test_fetch(self, mock_get):
        data = {
                "id": "0001",
                "name": "John Doe",
                }
        mock_response = Mock()
        mock_response.json.return_value = data
        
        mock_get.return_value = mock_response
        
        mock_session = Mock()
        
        retrieved_get_data = fetch_data_with_session(mock_session, "https://example-name/v1/", "0001")
        
        mock_get.assert_any_call("https://example-name/v1/0001")
        
        self.assertEqual = (outages_data, data)

if __name__ == '__main__':
    unittest.main()

Também tentei usar o mock.get.assert_called_withe obtive um erro semelhante.

assert_called_with
    raise AssertionError(error_message)
AssertionError: expected call not found.
Expected: get('https://example-name/v1/0001')
Actual: not called.

Novamente, presumo que não estou corrigindo a chamada GET corretamente, mas não tenho certeza de como corrigir isso.

EDIT: Obrigado @Guy que forneceu a resposta. O código do módulo atualizado está abaixo. Por favor, veja a resposta de @Guy para a explicação

@patch.object(requests.Session, 'get')
def test_fetch(self, mock_get):
    data = {
            "id": "exampleID",
            "name": "example",
            "devices": [
                {
                "id": "0001",
                "name": "Device A"
                }
            ]
            }
    mock_response = Mock()
    mock_response.json.return_value = data
    
    mock_get.return_value = mock_response
    
    outages_data = fetch_data_with_session(mock_get, "https://example-name/v1/", "0001")
    
    mock_get.get.assert_called_with("https://example-name/v1/0001")
    
    self.assertEqual = (outages_data, data)
python
Martin Hope
ph3rin
Asked: 2024-12-31 17:27:22 +0800 CST
  • 9

Eu estava tentando encontrar uma maneira de mixar fluxos de áudio com WebAudio e gravá-los com um MediaRecorder. Tenho seguido a abordagem descrita aqui:

Grave várias faixas de áudio disponíveis em um fluxo com o MediaRecorder

Parece que um nó de ganho (no exemplo deles, o nó de destino) pode executar mixagem em vários fluxos, como mostrado pelo meu experimento abaixo. No exemplo, você pode ouvir o tema Caribbean Pirates e o tema Universal Studios tocando quando você aperta o recordbotão.

Entretanto, no MDN diz que o nó de ganho (assim como o nó de destino) tem uma contagem de entrada de 1 .

Número de entradas = 1 insira a descrição da imagem aqui

Intuitivamente, algo com uma única entrada não pode executar mixagem! Estou esquecendo de algo aqui?

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>Web Audio Track Recorder</title>
</head>
<body>
  <h1>Web Audio Track Recorder</h1>
  <button id="recordButton">Start Recording</button>
  <script src="script.js"></script>
</body>
</html>

script.js

// URLs of the audio tracks:
const track1Url = 'https://archive.org/download/tvtunes_13046/Pirates%20of%20the%20Caribbean%20-%20Hes%20a%20Pirate.mp3';
const track2Url = 'https://archive.org/download/tvtunes_7590/Universal%20Studios.mp3';

// Initialize variables
let audioContext;
let source1, source2;
let mediaRecorder;
let audioChunks = [];
let isRecording = false;

// Function to start the audio context and load tracks
async function startAudio() {
  audioContext = new (window.AudioContext || window.webkitAudioContext)();

  // Load and decode the audio tracks
  const track1Data = await fetch(track1Url).then(response => response.arrayBuffer());
  const track2Data = await fetch(track2Url).then(response => response.arrayBuffer());

  const track1Buffer = await audioContext.decodeAudioData(track1Data);
  const track2Buffer = await audioContext.decodeAudioData(track2Data);

  // Create buffer sources
  source1 = audioContext.createBufferSource();
  source2 = audioContext.createBufferSource();

  source1.buffer = track1Buffer;
  source2.buffer = track2Buffer;

  // Create a gain node to control the volume
  const gainNode = audioContext.createGain();
  gainNode.gain.setValueAtTime(0.25, audioContext.currentTime);

  // Connect sources to the gain node
  source1.connect(gainNode);
  source2.connect(gainNode);

  // Connect gain node to the destination (speakers)
  gainNode.connect(audioContext.destination);

  // Create a MediaStream from the audio context
  const destination = audioContext.createMediaStreamDestination();
  gainNode.connect(destination);

  // Initialize MediaRecorder with the audio stream
  mediaRecorder = new MediaRecorder(destination.stream);

  // Event handler for when data is available
  mediaRecorder.ondataavailable = event => {
    audioChunks.push(event.data);
  };

  // Event handler for when recording stops
  mediaRecorder.onstop = () => {
    const audioBlob = new Blob(audioChunks, { type: 'audio/webm' });
    const audioUrl = URL.createObjectURL(audioBlob);
    const downloadLink = document.createElement('a');
    downloadLink.href = audioUrl;
    downloadLink.download = 'recording.webm';
    downloadLink.click();
    audioChunks = [];
  };

  // Start the sources
  source1.start();
  source2.start();
}

// Function to toggle recording
function toggleRecording() {
  if (!isRecording) {
    if (!audioContext) {
      startAudio().then(() => {
        mediaRecorder.start();
        document.getElementById('recordButton').textContent = 'Stop Recording';
      });
    } else {
      mediaRecorder.start();
      document.getElementById('recordButton').textContent = 'Stop Recording';
    }
  } else {
    mediaRecorder.stop();
    document.getElementById('recordButton').textContent = 'Start Recording';
  }
  isRecording = !isRecording;
}

// Add event listener to the record button
document.getElementById('recordButton').addEventListener('click', toggleRecording);

Você também pode tentar aqui: https://jsfiddle.net/10ms7pyd/8/

javascript
Martin Hope
Avi
Asked: 2024-12-31 16:26:11 +0800 CST
  • 9
#include <iostream>

using namespace std;

int main()
{
   // Case 1
   cout << &5; // This line fails to compile. Ok, I get this because "5" is a rvalue.
   
   // Case 2
   const int& ref = 5;
   cout << &ref; // Works fine. Why?

   // Case 3
   cout << &"SomeString"; // Works  fine. Ok, I get this because "SomeString" is a lvalue
    
   return 0;
}

Por que o caso 1 falha e o caso 2 passa? Não consegui encontrar explicação concreta em nenhum outro lugar. A maioria das respostas era confusa e autocontraditória.

Eu entendo que "5" em literal inteiro e é um rvalue (não podemos pegar o endereço dele). Então, o que de especial uma referência const lvalue no caso 2 faz, que permite pegar o endereço de "5"? Como eu li, uma referência (seja lvalue ou rvalue) é apenas um alias. Ela não tem endereço próprio.

c++
Martin Hope
vs07
Asked: 2024-12-31 15:31:52 +0800 CST
  • 9

Tenho o seguinte script comparando o tempo que leva para declarar um objeto com uma classe em comparação diretamente com um objeto.

console.time("class decls");
class Dog {
        a;
        constructor() {
            this.a = 1;
        }
        bark() {
            this.a + this.a;
        }
    }

for (let i = 0; i < 1_000_000; ++i) {
    let dog = new Dog();
    dog.bark();
}
console.timeEnd("class decls");

console.time("object decls");
for (let i = 0; i < 1_000_000; ++i) {
    let dog = {
        a: undefined,
        bark() {
            this.a + this.a;
        }
    }
    { // inlining the constructor
        dog.a = 1;
    }
    dog.bark();
}
console.timeEnd("object decls");

Os resultados parecem favorecer fortemente o primeiro método, apresentando os seguintes tempos quando executado com Bun e resultados semelhantes quando executado com Node:

[8.46ms] class decls
[27.98ms] object decls

Por que é muito mais rápido declarar uma classe e então construir um novo objeto dela? Há algum cache acontecendo ou é outra coisa?

javascript
Martin Hope
john v kumpf
Asked: 2024-12-29 00:56:27 +0800 CST
  • 9

Por algum motivo, o powershell não me deixa converter a string[]em an object[], mas permite para todos os outros tipos. O exemplo abaixo mostra que funciona para vários tipos, exceto string.

     [int[]]$intary = 2,4
    [char[]]$chrary = 'a','b'
    [bool[]]$booary = $true,$false
[DateTime[]]$datary = (Get-Date),(Get-Date)
  [string[]]$strary = 'c','d'
            $splary = 'e,f' -split ','  # -split returns [string[]] type specifically
  [object[]]$objaryi = @()
  [object[]]$objaryc = @()
  [object[]]$objaryb = @()
  [object[]]$objaryd = @()
  [object[]]$objarys = @()
  [object[]]$objarysp = @()
$intary.GetType()           # Int32[]
$chrary.GetType()           # Char[] 
$booary.GetType()           # Boolean[]
$datary.GetType()           # DateTime[]
$strary.GetType()           # String[]
$splary.GetType()           # String[]
$objaryi.GetType()          # Object[]

'conversions'
$objaryi = $intary          # Int32[] converted to Object[]
$objaryi.GetType()          # Object[]

$objaryc = $chrary          # Char[] converted to Object[]
$objaryc.GetType()          # Object[]

$objaryb = $booary          # Boolean[] converted to Object[]
$objaryb.GetType()          # Object[]

$objaryd = $datary          # DateTime[] converted to Object[]
$objaryd.GetType()          # Object[]

$objarys = $strary          # NOT converted to Object[]; instead changes type of $objarys to String[]
$objarys.GetType()          # String[]

$objarysp = $splary         # NOT converted to Object[]; instead changes type of $objarysp to String[]
$objarysp.GetType()         # String[]

$objarys = @($strary)       # the array subexpression operator @() DOES convert to Object[]
$objarys.GetType()          # Object[]

$objarysp = @($splary)       # the array subexpression operator @() DOES convert to Object[]
$objarysp.GetType()          # Object[]

'inline cast'
$objarys = @([string[]]@(1,2)) # the array subexpression operator @() does not work on an inline cast [1]
$objarys.GetType()          # String[]

Uma razão pela qual isso importa é que se você tentar armazenar um hash em um array que é tipado, string[]o powershell converterá silenciosamente sua definição de hash para uma string. A string é o sting para o caminho completo typename do hash.

$objaryi[0] = @{a=1;b=2}    # can hold a hashtable because it's now an Object[]
$objaryi[0].GetType()       # Hashtable
$objaryi[0]['b']            # 2

$objarys[0] = @{a=1;b=2}    # silently converts to a string because it's a String[]
$objarys[0].GetType()       # String
$objarys[0]['b']            # $null; perhaps unexpected
$objarys[0]                 # the String value "System.Collections.Hashtable"
$objarys[0].Length          # 28
powershell
Martin Hope
mrroy
Asked: 2024-12-28 22:31:29 +0800 CST
  • 9

Apesar de ler muitos tutoriais, ainda não está claro para mim o que está sendo passado de volta de uma reactiveexpressão/bloco de código, especialmente quando os blocos de código dentro dele reactivese tornam maiores. Fiz alguns testes básicos, assumindo que reactiveConsole(TRUE)é uma maneira adequada de testar essas coisas.

O resumo a seguir é preciso?

  • sem uma declaração explícita return, reactivesempre retorna o valor produzido pela última declaração dentro de sua expressão, independentemente de esse valor ter sido atribuído a uma variável local (mas veja o comportamento "inesperado" nos exemplos abaixo)
  • use returninstruções explícitas para evitar retornar o resultado da instrução final, por exemplo, para evitar retornar uma printinstrução de depuração no final da expressão, para criar uma lógica if/else sobre o que retornar, etc.

Se houver outras variações importantes ou exceções a esse comportamento que valham a pena mencionar, por favor, faça-o.

library(shiny)
reactiveConsole(TRUE)

#------single line-----
#direct assignment
x = reactive({5})
x() #-> 5

ans = x()
ans #-> 5

#assign value to local variable, return
x = reactive({tmp = 5
return(tmp)})
x() #-> 5

ans = x()
ans #-> 5

#assign value to local variable, don't return
x = reactive({tmp = 5})
x() #-> [no response]

ans = x()
ans #-> 5 [value unexpectedly returns]


#-----multi-line---
#direct assignment: final line is retained
x = reactive({5
  10})
x() #-> 10

ans = x()
ans #-> 10


#return requested local var, tmp
x = reactive({tmp = 5
tmp2 = 10
return(tmp)})
x() #-> 5

ans = x()
ans #-> 5

#return requested local var, tmp2
x = reactive({tmp = 5
tmp2=10
return(tmp2)})
x() #-> 10

ans = x()
ans #-> 10

#without return
x = reactive({tmp = 5
tmp2 = 10})
x() #-> [no response]

ans = x()
ans #-> 10 [value unexpectedly returns]
Martin Hope
xmllmx
Asked: 2024-12-27 23:49:18 +0800 CST
  • 9

Considere o seguinte código:

#include <concepts>

struct T1 {};

struct T2 {};

struct T3 {};

struct T4 {};

void bar(T1, T2, T3, T4) {
}

template<typename T>
concept IsT = std::same_as<T, T1> || std::same_as<T, T2> ||
              std::same_as<T, T3> || std::same_as<T, T4>;

void foo(IsT auto x1, IsT auto x2, IsT auto x3, IsT auto x4) {
    // How to order the types of x1, x2, x3, x4 and call bar(x?, x?, x?, x?)?
}

int main() {
    foo(T1{},T2{},T3{},T4{}); // ok
    foo(T4{},T3{},T2{},T1{}); // ok
    foo(T3{},T2{},T1{},T4{}); // ok
    // ...
}

Minha intenção é simples:

O usuário pode chamar fooem qualquer ordem de argumentos, mas finally barserá chamado com os argumentos na ordem correta.

A solução trivial é usar força bruta para dividir os 24 casos, o que é obviamente tedioso e propenso a erros.

Existe uma maneira sem força bruta de resolver esse problema? Estou usando C++20.

c++
Martin Hope
cpp is hard
Asked: 2024-12-26 21:27:45 +0800 CST
  • 9

Estou implementando um BST e acredito que é uma boa ideia usar unique_ptr para representar a propriedade do nó filho. No entanto, descobri que ponteiros inteligentes fazem com que o compilador prefira ramificação em vez de código sem ramificação (especificamente cmov). Estou usando g++-13 para compilar no Ubuntu 24.04.1 LTS. Tentei usar o operador ternário para encorajar código sem ramificação, mas não funcionou. Aqui está um protótipo simples

#include <memory>
#include <iostream>
struct node {
    int val;
    node* left_child;
    node* right_child;
};

struct smart_node {
    int val;
    std::unique_ptr<smart_node> left_child;
    std::unique_ptr<smart_node> right_child;
};

node*
__attribute__((noinline))
raw(node* root, int key) {
    node* prev = root;
    node* curr = prev -> left_child;
    while (curr != nullptr) {
        prev = curr;
        bool comp = key < (curr -> val);
        curr = comp ? curr -> left_child : curr -> right_child;
    }
    return prev;
}

smart_node*
__attribute__((noinline))
smart(std::unique_ptr<smart_node> root, int key) {
    smart_node* prev = root.get();
    smart_node* curr = prev -> left_child.get();
    while (curr != nullptr) {
        prev = curr;
        bool comp = key < (curr -> val);
        curr = comp ? curr -> left_child.get() : curr -> right_child.get();
    }
    return prev;
}

int main() {
    // Use null instead of a non-degenerative tree to shorten the code
    // I verified this doesn't cause the assembly of the two functions above to mutate
    auto last1 = raw(nullptr, 1);
    auto last2 = smart(std::make_unique<smart_node>(), 1);
    std::cout << last1 -> val << last2 -> val;
}

Abaixo está o código de montagem para o loop em raw.

    1310:   48 89 c2                mov    %rax,%rdx
    1313:   48 8b 42 10             mov    0x10(%rdx),%rax
    1317:   3b 32                   cmp    (%rdx),%esi
    1319:   48 0f 4c 42 08          cmovl  0x8(%rdx),%rax
    131e:   48 85 c0                test   %rax,%rax
    1321:   75 ed                   jne    1310 <_Z3rawP4nodei+0x20>

Abaixo está o código de montagem para o loop em smart.

    1360:   48 8b 50 08             mov    0x8(%rax),%rdx
    1364:   48 85 d2                test   %rdx,%rdx
    1367:   74 10                   je     1379 <_Z5smartSt10unique_ptrI10smart_nodeSt14default_deleteIS0_EEi+0x39>
    1369:   48 89 d0                mov    %rdx,%rax
    136c:   3b 30                   cmp    (%rax),%esi
    136e:   7c f0                   jl     1360 <_Z5smartSt10unique_ptrI10smart_nodeSt14default_deleteIS0_EEi+0x20>
    1370:   48 8b 50 10             mov    0x10(%rax),%rdx
    1374:   48 85 d2                test   %rdx,%rdx
    1377:   75 f0                   jne    1369 <_Z5smartSt10unique_ptrI10smart_nodeSt14default_deleteIS0_EEi+0x29>

No benchmark (chamada 2e6 para uma árvore com nós 2e6), o código de ramificação leva cerca de 1,4x o tempo da versão sem ramificação. Eu usei RelWithDebInfopara que a otimização O2 esteja ativada. Minha pergunta é como posso forçar o compilador a usar cmov? Eu li esta postagem e parece que não há uma maneira limpa de forçar esse comportamento. Se não for possível, gostaria de saber por que o compilador gera código diferente para os dois casos.

Para esclarecer, não quero assembly, pois ele não é portátil. Usei assembly para forçar a versão branchless, mas não é a direção que quero seguir.

c++
Martin Hope
Matvey Androsyuk
Asked: 2024-12-26 14:17:10 +0800 CST
  • 9

Eu tenho um componente chamado TreeNode, que é um arquivo na minha estrutura de árvore.

import React from "react";
import classes from "./TreeNode.module.css"

function TreeNode({children, title}){
    return(
        <div>
            <div className={classes.treeNode}>
                <div className={classes.treeNodeType}>
                    <svg xmlns="http://www.w3.org/2000/svg" fill="#3B4045" x="0px" y="0px" width="20" height="20" viewBox="0 0 20 20">
                        <path d="M20,6h-8l-2-2H4C2.9,4,2,4.9,2,6v12c0,1.1,0.9,2,2,2h16c1.1,0,2-0.9,2-2V8C22,6.9,21.1,6,20,6z"></path>
                    </svg>
                </div>
                <div className={classes.treeNodeTitle}>
                    {title}
                </div>
            </div>
        </div>
    )
}

export default TreeNode;

E eu tenho um arquivo que contém objetos fictícios de arquivo que eu quero desenhar na minha página como uma árvore.

const files = [
    {
        id: 232141332,
        title: "Оборудование",
        type: "FOALDER",
        opened: false,
        level: 0,
        fatherId: null,
        children: [
            {
                id: 734573086,
                title: "MA5600",
                type: "FOALDER",
                opened: false,
                level: 1,
                fatherId: 232141332,
                children: [
                    {
                        id: 867407333,
                        title: "Удаление платы",
                        type: "FILE",
                        opened: false,
                        level: 2,
                        fatherId: 734573086,
                        children: []
                    },
                    {
                        id: 110345245,
                        title: "Добавление платы",
                        type: "FILE",
                        opened: false,
                        level: 2,
                        fatherId: 734573086,
                        children: []
                    }
                ]
            },
            {
                id: 222225454,
                title: "C300M",
                type: "FOALDER",
                opened: false,
                level: 1,
                fatherId: 232141332,
                children: [
                    {
                        id: 333334256,
                        title: "Не найдена опция TR-82",
                        type: "FILE",
                        opened: false,
                        level: 2,
                        fatherId: 222225454,
                        children: []
                    }
                ]
            }
        ]
    }
]

export default files;

Como escrever meu arquivo Main.jsx para renderizar todos esses arquivos.

import files from "../../mock/files";
import "../../styles/Main.css"
import TreeNode from "../treenode/TreeNode";

function Main() {
    return (
      <div className="wrapper">
        <div className="tree">
            {
                files.map((file) => {
                    //code
                })
            }
        </div>
      </div>
    );
  }
  
  export default Main;

Talvez eu precise refatorar algum código, não sei, mas no segundo dia não consigo fazer isso.

javascript
Martin Hope
joran
Asked: 2024-12-24 07:50:14 +0800 CST
  • 9

Nele ?formuladiz:

Há duas interpretações especiais de . em uma fórmula. A usual é no contexto de um argumento de dados de funções de ajuste de modelo e significa 'todas as colunas que não estão na fórmula': veja terms.formula. No contexto de update.formula, somente, significa 'o que estava anteriormente nesta parte da fórmula'.

Minha leitura da primeira parte desse pedaço de documentação me levou a supor que este código:

dat <- data.frame(
  y = rnorm(10),
  x1 = runif(10),
  x2 = rbinom(10,size = 1,prob = 0.5),
  x3 = rbinom(10,size = 1,prob = 0.5)
)

mt <- terms.formula(
  x = y ~ x1 + . + (.)^2,
  data = dat
)

mm <- model.matrix(mt,dat)

...produziria uma matriz modelo com um termo de interação somente para x2:x3, já que essas são as únicas duas colunas em dat"não de outra forma na fórmula". No entanto:

> colnames(mm)
[1] "(Intercept)" "x1"          "x2"          "x3"          "x1:x2"      
[6] "x1:x3"       "x2:x3"

...em vez disso, obtemos todas as interações.

Se eu escrever explicitamente, é claro, obtenho o que espero:

> mt1 <- terms.formula(
+   x = y ~ x1 + x2 + x3 + (x2 + x3)^2,
+   data = dat
+ )
> 
> mm1 <- model.matrix(mt1,dat)
> colnames(mm1)
[1] "(Intercept)" "x1"          "x2"          "x3"          "x2:x3"

Sei que fórmulas e matrizes de modelos às vezes são sutilmente confusas, mas estou tendo dificuldade em conciliar minha leitura da documentação com o comportamento.

Estou interpretando a documentação incorretamente, ou possivelmente escrevendo a fórmula incorretamente (para o que estou tentando fazer)? Ou a documentação não é totalmente precisa?

Prev
Próximo