All perguntas(coding)

Digamos que temos o seguinte código:

function test() {
  const a = {<HERE>}; // `<HERE>` is the caret position
}

Quando enterpressionado, os espaços em branco à esquerda são adicionados conforme o esperado:

function test() {
  const a = {
  <HERE>};
}

Quando o próximo enterfor pressionado:

function test() {
  const a = {

  <HERE>};
}

Como voltar à linha anterior sem perder os espaços em branco à esquerda? Quando pressiono <C-o>e k:

function test() {
  const a = {
<HERE>
  };
}

Parece que não depende do tipo de arquivo. Tenho o mesmo comportamento em arquivos TypeScript e Rust (não verifiquei outros tipos).

Tenho dados brutos que aparecem assim:

┌─────────┬────────┬─────────────────────┐
│  price  │  size  │      timestamp      │
│  float  │ uint16 │      timestamp      │
├─────────┼────────┼─────────────────────┤
│  1697.0 │     11 │ 2009-09-27 18:00:00 │
│  1697.0 │      5 │ 2009-09-27 18:00:00 │
│  1697.0 │      5 │ 2009-09-27 18:00:00 │
│  1697.0 │      5 │ 2009-09-27 18:00:00 │
│  1697.0 │      5 │ 2009-09-27 18:00:00 │
│  1697.0 │      4 │ 2009-09-27 18:00:00 │
│  1697.0 │      1 │ 2009-09-27 18:00:00 │
│  1697.0 │      1 │ 2009-09-27 18:00:00 │
│  1697.0 │      1 │ 2009-09-27 18:00:00 │
│  1697.5 │      3 │ 2009-09-27 18:00:00 │
│  1697.5 │      2 │ 2009-09-27 18:00:00 │
│  1697.0 │      1 │ 2009-09-27 18:00:00 │
│  1698.0 │      1 │ 2009-09-27 18:00:01 │
│ 1698.25 │      1 │ 2009-09-27 18:00:01 │
│ 1698.25 │     10 │ 2009-09-27 18:00:02 │
│ 1698.25 │      4 │ 2009-09-27 18:00:02 │
│ 1697.25 │      6 │ 2009-09-27 18:00:02 │
│ 1697.25 │      2 │ 2009-09-27 18:00:02 │
│  1697.0 │     28 │ 2009-09-27 18:00:02 │
│ 1697.25 │      6 │ 2009-09-27 18:00:03 │
├─────────┴────────┴─────────────────────┤
│ 20 rows                      3 columns │

Usando o DuckDB, eu queria criar histogramas para cada registro de data e hora, tanto o preço quanto o tamanho.

Minha tentativa:

    vp = conn.query(f"""
      SET enable_progress_bar = true;
      SELECT
        timestamp,
        histogram(price)
      FROM 'data/tickdata.parquet'
      GROUP BY timestamp
      ORDER BY timestamp

                    """)

Isso produz o seguinte:

┌─────────────────────┬─────────────────────────────────────────────────────────────────┐
│      timestamp      │                        histogram(price)                         │
│      timestamp      │                       map(float, ubigint)                       │
├─────────────────────┼─────────────────────────────────────────────────────────────────┤
│ 2009-09-27 18:00:00 │ {1697.0=10, 1697.5=2}                                           │
│ 2009-09-27 18:00:01 │ {1698.0=1, 1698.25=1}                                           │
│ 2009-09-27 18:00:02 │ {1697.0=1, 1697.25=2, 1698.25=2}                                │
│ 2009-09-27 18:00:03 │ {1696.0=2, 1696.5=2, 1697.0=2, 1697.25=1}                       │
│ 2009-09-27 18:00:04 │ {1696.0=2, 1696.25=2, 1696.75=1, 1697.0=1, 1697.25=3, 1697.5=1} 

À primeira vista, "parece correto", porém, os "valores" associados a cada chave não são a SOMA do tamanho, mas sim as CONTAGENS do tamanho. O que eu esperaria ver:

┌─────────────────────┬─────────────────────────────────────────────────────────────────┐
│      timestamp      │                        histogram(price)                         │
│      timestamp      │                       map(float, ubigint)                       │
├─────────────────────┼─────────────────────────────────────────────────────────────────┤
│ 2009-09-27 18:00:00 │ {1697.0=39, 1697.5=5}                                           │
│ 2009-09-27 18:00:01 │ {1698.0=1, 1698.25=1}                                           │
│ 2009-09-27 18:00:02 │ {1697.0=28, 1697.25=8, 1698.25=14}    

Alternativamente: consigo gerar a tabela a seguir, mas não tenho certeza se há uma maneira de mapeá-la no exemplo acima?

┌─────────────────────┬─────────┬───────────┐
│      timestamp      │  price  │ sum(size) │
│      timestamp      │  float  │  int128   │
├─────────────────────┼─────────┼───────────┤
│ 2009-09-27 18:00:00 │  1697.0 │        39 │
│ 2009-09-27 18:00:00 │  1697.5 │         5 │
│ 2009-09-27 18:00:01 │  1698.0 │         1 │
│ 2009-09-27 18:00:01 │ 1698.25 │         1 │
│ 2009-09-27 18:00:02 │ 1698.25 │        14 │
│ 2009-09-27 18:00:02 │ 1697.25 │         8 │
│ 2009-09-27 18:00:02 │  1697.0 │        28 │

Está funcionando na minha tela e na tela de alguns testadores, mas alguns testadores com tela menor estão abrindo um novo link em vez do pop-up

HTML:

<a class="popup-video" href="videos/onequote 1.mp4">
  <img src="images/thumb1.png">
</a>

ROTEIRO:

$(function() {
                $('.popup-video').magnificPopup({
                    disableOn: 1000,
                    type: 'iframe',
                    mainClass: 'mfp-fade',
                    removalDelay: 160,
                    preloader: false,
                    fixedContentPos: false
                });
            });

Este é meu script Bash:

#!/bin/bash

#Colors for terminal

#RED
R="\e[31m"

#GREEN
G="\e[32m"

#YELLOW
Y="\e[33m"

#NORMAL
N="\e[0m"

validation(){

    if [ $1 -eq 0 ];
    then 
        echo -e "${G}$2 is successful${N}"
    else 
        echo -e "${R}$2 has Failed${N}"
        exit 1;
    fi
}

echo -e "${Y}Configuring Cart Service${N}"

cart_config="/etc/systemd/system/cart.service"

cat << EOF >$cart_config

Environment=REDIS_HOST="${redis_ip}" #I want TF to only substitute these
Environment=CATALOGUE_HOST="${app_lb_dns}"

Environment=CATALOGUE_PORT=8082

EOF

validation $? "Configuring Cart Service"

Receberei meu endereço IP do Redis e o DNS do balanceador de carga após criá-los no Terraform, e quero passar um script bash como dados do usuário com esses valores substituídos. O problema é que o Terraform tenta substituir todas as variáveis ${}​​dentro do script bash, mas eu só quero que ele substitua ${redis_ip}e ${app_lb_dns}nos dados do usuário. Tentei escapar todas as variáveis ​​usando \${}e $${}, mas sem sucesso.

Erro:

20: user_data = base64encode(templatefile("../userdata/cart.sh", { redis_ip = data.aws_ssm_parameter.redis_ip.value, app_lb_dns = data.aws_ssm_parameter.app_lb_dns.value })) ao chamar templatefile(path, vars) Valor inválido para o parâmetro "vars": o mapa vars não contém a chave "G", referenciado em ../userdata/cart.sh:16,21-22.

Conforme o erro, o TF está tentando substituir uma variável relacionada ao script bash.

Este é meu código Terraform:

user_data = base64encode(templatefile("../userdata/cart.sh", { redis_ip = data.aws_ssm_parameter.redis_ip.value, app_lb_dns = data.aws_ssm_parameter.app_lb_dns.value }))

Python Sql Alchemy gera tabela com VARCHAR para SQL Lite em vez de INTEGER, então selecione para SQL Lite ordenado por número alfabético

Dada a tabela City no SQL Lite gerada pelo SQL Alchemy:

class City(Base):
__tablename__ = "city"
id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
city_name: Mapped[str] = mapped_column(String, index=True)

Ele gera:

Dados:

15470   Paris
100567  Paris

Consulta:

select(City).where(City.city_name == city_name.upper()).order_by(City.id).limit(1)

SELECT city.id, city.city_name 
FROM city 
WHERE city.city_name = :city_name_1 ORDER BY city.id
LIMIT :param_1

retorna o ID da cidade com 100567 em vez de 15470.

Preciso fornecer um exemplo com inserção SQL também?

Estou com dificuldade para entender se realmente há diferença entre as duas afirmações:

Image->Picture->Bitmap = bitmap;  // bitmap is a TBitmap object
Image->Picture->Assign(bitmap);

A ajuda do VCL diz claramente sobre a tarefa via =:

Observação: Ao atribuir a propriedade Bitmap, TPicture atribui as propriedades de outro objeto TBitmap. Ele não assume a propriedade do valor especificado.

Isso significa que a primeira instrução NÃO copia o bitmap, masImage->Picture->Bitmap apenas o endereço do bitmapé assumido por Image->Picture->Bitmap.

Image->Picture->BitmapPor que a imagem na tela está sendo exibida corretamente mesmo depois de eu ter excluído o objeto bitmap ?

Posso encontrar a data do próximo domingo (ou hoje, se hoje for domingo) sem problemas usando timedelta com a linha:

print(datetime.date.today() + datetime.timedelta(7 - int(time.strftime("%u"))))

E eu posso pegar a data de hoje e formatá-la da maneira que eu quiser usando strftime com a linha:

print(datetime.date.today().strftime("%d.%m.%Y"))

Mas não consigo, nem que me esforce, descobrir como fazer com que esses dois se comportem bem para que eu possa ter o encontro do próximo domingo no formato que eu quero. O resultado que obtenho executando esses dois individualmente é

2025-05-04
27.04.2025

Mas eu quero 05/04/2025. Sei que poderia inserir 2025-05-04 em str() e depois formatá-lo, mas isso parece desajeitado. Gostaria de descobrir como usar strftime nessa situação, porque tenho quase certeza de que o que estou tentando fazer é exatamente o que ele se destina.

Conheço duas maneiras de chamar o construtor de uma superclasse a partir de uma classe derivada: super().__init__()e base.__init__(self). Por que a segunda exige que eu forneça explicitamente selfcomo argumento?

Aqui está um trecho que demonstra a diferença:

class base:
    def __init__(self,/):
        print("initializing")

class der(base):
    def __init__(self):
        super().__init__()  #no error
        base.__init__(self) #no error
        base.__init__() #error, self required

obj = der()

A terceira chamada do construtor gera este erro:

File "demo.py", line 11, in <module>
    obj = der()
          ^^^^^
  File "demo.py", line 9, in __init__
    base.__init__() #error, should be: base.__init__(self)
    ^^^^^^^^^^^^^^^
TypeError: base.__init__() missing 1 required positional argument: 'self'

Espero base.__init__()que funcione, pois super().__init__()não requer um explícito self.

No momento, estou considerando usar o Quartz em um projeto ASP.NET para agendar tarefas. Basicamente, o aplicativo permite que os usuários criem menus que podem ser enviados para dispositivos. No momento, eles só têm a opção de enviar um menu no momento atual, mas quero implementar uma opção para agendar o envio para uma data posterior (por exemplo, no COB na terça-feira, em um fim de semana, em uma tarefa recorrente toda segunda-feira às 7h, etc.).

Consegui implementar isso armazenando o trabalho na memória, no entanto, essa obviamente não é a melhor prática e gostaria de armazenar esses trabalhos em um banco de dados - é aí que estou um pouco preso no momento...

Temos um banco de dados existente (no SQL Server) ao qual adicionaremos as tabelas necessárias, porém o script no GitHub para Quartz tem um grande número de tabelas... Acho que minha pergunta é: qual é o número mínimo de tabelas que realmente preciso criar e o que posso excluir? É possível criar minha própria tabela para minha situação específica (e se sim, como)?

Resumindo:

• Usando Quarts no meu projeto ASP.NET para agendar tarefas em momentos posteriores
• Esses trabalhos têm parâmetros (id dos dispositivos, etc.)
• Atualmente implementado e funcionando, armazenando na memória, mas gostaria de armazenar esses trabalhos/gatilhos em um banco de dados
• O script do Quartz é bastante grande e cria um grande número de tabelas
• Quais são as tabelas mínimas/necessárias que realmente preciso?

Se precisar de mais detalhes, fique à vontade para perguntar :)

Implementado agendamento em memória - funcionando. Atualmente, busco informações no Quartz DB antes de criar tabelas.

Fiquei surpreso ao ver que, ao contrário do Vector256, o ExtractMostSignificantBits do Vector64 não usa um intrínseco para fazer seu trabalho. Usar o intrínseco transforma estas 36 linhas:

mov      qword ptr [rsp+0x80], r12
movzx    rdx, byte  ptr [rsp+0x80]
shr      edx, 7
movzx    r8, byte  ptr [rsp+0x81]
shr      r8d, 7
add      r8d, r8d
or       edx, r8d
movzx    r8, byte  ptr [rsp+0x82]
shr      r8d, 7
shl      r8d, 2
or       r8d, edx
mov      edx, r8d
movzx    r8, byte  ptr [rsp+0x83]
shr      r8d, 7
shl      r8d, 3
or       r8d, edx
mov      edx, r8d
movzx    r8, byte  ptr [rsp+0x84]
shr      r8d, 7
shl      r8d, 4
or       r8d, edx
mov      edx, r8d
movzx    r8, byte  ptr [rsp+0x85]
shr      r8d, 7
shl      r8d, 5
or       r8d, edx
mov      edx, r8d
movzx    r8, byte  ptr [rsp+0x86]
shr      r8d, 7
shl      r8d, 6
or       r8d, edx
mov      edx, r8d
movzx    r8, byte  ptr [rsp+0x87]
shr      r8d, 7
shl      r8d, 7
or       r8d, edx

Nestes 4:

mov      qword ptr [rsp+0x70], rcx
mov      r10, qword ptr [rsp+0x70]
mov      r15, 0x8080808080808080
pext     r10, r10, r15

Parece que você poderia implementá-lo no Vector64.cs com algo assim:

public static uint ExtractMostSignificantBits<T>(this Vector64<T> vector)
{
    if (Bmi2.X64.IsSupported)
    {
        ulong mask = 0;

        if (typeof(T) == typeof(byte) || typeof(T) == typeof(sbyte))
            mask = 0x8080808080808080;
        else if (typeof(T) == typeof(short) || typeof(T) == typeof(ushort))
            mask = 0x8000800080008000;
        else if (typeof(T) == typeof(int) || typeof(T) == typeof(uint) || typeof(T) == typeof(float))
            mask = 0x8000000080000000;
        else if (typeof(T) == typeof(long) || typeof(T) == typeof(ulong) || typeof(T) == typeof(double))
            mask = 0x8000000000000000;
        else if (typeof(T) == typeof(nint) || typeof(T) == typeof(nuint))
            if (IntPtr.Size == 4)
                mask = 0x8000000080000000;
            else
                mask = 0x8000000000000000;

        ulong u = vector._00;

        ulong retval = Bmi2.X64.ParallelBitExtract(u, mask);

        return (uint)retval;
    }

    // Fall back to the old code
    uint result = 0;
    for (int index = 0; index < Vector64<T>.Count; index++)
    {
        uint value = Scalar<T>.ExtractMostSignificantBit(vector.GetElementUnsafe(index));
        result |= (value << index);
    }

    return result;
}

Não é como se o BMI2 fosse mais "novo", tendo sido introduzido por volta de 2013. Além disso, considerando a compilação JIT, não há muito custo em fazê-lo dessa maneira.

Eu escrevi um código de teste (disponível mediante solicitação) e ele produz os mesmos resultados que o código existente, apenas um pouco mais que o dobro da velocidade (possivelmente ainda mais rápido com algumas melhorias no Vector64.GetElementUnsafe).

Há alguma nuance ou caso especial aqui que eu tenha esquecido e que torna o uso do intrínseco inaceitável? Ou alguém simplesmente esqueceu disso?