All perguntas(coding)

Depois de pesquisar sobre esse assunto, não tenho certeza se é realmente possível fazer isso. Obrigado por qualquer dica.

Minha visão é criada assim:

create or replace view OutputView as
select * from view1
natural full outer join view2;

Usando:

update OutputView set colA = 'undefined' where colA is null;

dá:

ERROR:  cannot update view "OutputView"
DETAIL:  Views that do not select from a single table or view are not automatically updatable.
HINT:  To enable updating the view, provide an INSTEAD OF UPDATE trigger or an unconditional ON UPDATE DO INSTEAD rule.

Sem sorte até agora com esse gatilho e regra. O problema é que algumas colunas na visualização de saída têm valores nulos porque essas colunas não existem nas visualizações originais, por exemplo:

view1
-----
colA colB
1    a
2    b

view2
-----
colB colC
100  x
200  y

OutputView
----------
colA  colB  colC
1     a     null
2     b     null
null  100   x
null  200   y

Tenho dois tipos, CustomNotCompatibleWithRun, CustomCompatibleWithRun, e uma run()função:

#include <iostream>
#include <type_traits>

template <typename T_>
struct CustomNotCompatibleWithRun { using T = T_; };

template <typename T_>
struct CustomCompatibleWithRun {
    using T = T_; 
    
    CustomCompatibleWithRun operator+(const CustomCompatibleWithRun& other)
    {
        CustomCompatibleWithRun res;
        res.a = a + other.a;
        res.b = b + other.b;
        return res;
    }
    
    void print() const
    {
        std::cout << "a, b = " << a << ", " << b << "\n";
    }
    
    T a;
    T b;
};

template <typename T>
T run(T a, T b) { return a+b; }

Quero escrever uma característica de tipo, IsTypeCompatibleWithRun, que verifica se um dado Type(cujo único contrato é ter um alias de tipo Type::T) pode ser usado na run()função. Ou seja:

int main() {
    using T = float;
    CustomCompatibleWithRun<T> obj1{.a = 1.f, .b = 2.f};
    CustomCompatibleWithRun<T> obj2{.a = 2.f, .b = 3.f};
    obj1.print(); // a, b = 1, 2
    obj2.print(); // a, b = 2, 3
    const auto obj3 = obj1 + obj2;
    obj3.print(); // a, b = 3, 5
    const auto obj4 = run(obj1, obj2);
    obj4.print(); // a, b = 3, 5
    CustomNotCompatibleWithRun<T> obj5{};
    CustomNotCompatibleWithRun<T> obj6{};
    // const auto obj7 = obj5 + obj6; // does not compile
    
    std::cout << "IsTypeCompatibleWithRun<CustomCompatibleWithRun>::value: " << IsTypeCompatibleWithRun<CustomCompatibleWithRun<T>>::value << "\n"; // should print 1
    std::cout << "IsTypeCompatibleWithRun<CustomNotCompatibleWithRun>::value: " << IsTypeCompatibleWithRun<CustomNotCompatibleWithRun<T>>::value << "\n"; // should print 0
}

Tentei as três opções abaixo:

template <typename Type, typename = void>
struct IsTypeCompatibleWithRun : std::false_type {};

// Option 1
template <typename Type>
struct IsTypeCompatibleWithRun<Type, decltype(void(run<typename Type::T>(std::declval<typename Type::T>(), std::declval<typename Type::T>())))> : std::true_type {};

// Option 2
template <typename Type>
struct IsTypeCompatibleWithRun<Type, decltype(void(std::declval<Type>() + std::declval<Type>()))> : std::true_type {};

// Option 3
template <typename Type>
struct IsTypeCompatibleWithRun<Type, std::void_t<decltype(run(std::declval<Type>(), std::declval<Type>()))>> : std::true_type {};

E apenas a Opção 2 funciona — pelo que entendi, isso ocorre porque forçamos o +operador dentro da própria característica de tipo, enquanto nas Opções 1 e 3, apenas a assinatura da run()função é verificada. No entanto, estou insatisfeito com a Opção 2 porque ela exige a repetição do corpo da função run()na própria característica de tipo. Neste exemplo simples, funciona bem, mas na minha aplicação, o corpo da run()função é muito mais complexo e é impossível repeti-lo dentro da característica de tipo.

Então tentei mudar a assinatura de run()para

template <typename T>
auto run(T a, T b)

mas o código nem compilava mais. Então tentei adicionar um tipo de retorno final

template <typename T>
auto run(T a, T b) -> decltype(a+b)

e agora a Opção 3 funcionaria, mas não a Opção 1. Por que isso?

De qualquer forma, o acima envolveria ter que repetir a a+bparte no tipo de retorno final, então não é uma solução para mim.

Existe uma maneira de obter esse traço de tipo sem alterar run()e depender apenas run()(e não repetir) seu corpo de função em C++ 14?

Estou tentando adicionar um tipo de parâmetro ao readinto()método declarado em uma classe personalizada que deriva de RawIOBase, assim:

from io import RawIOBase

class Reader(RawIOBase):
    def readinto(self, buf: bytearray) -> int:
        pass  # actual implementation omitted

Mas os direitos autorais reclamam:

io.py:6:9 - error: Method "readinto" overrides class "_RawIOBase" in an incompatible manner
    Parameter 2 type mismatch: base parameter is type "WriteableBuffer", override parameter is type "bytearray"
      "Buffer" is not assignable to "bytearray" (reportIncompatibleMethodOverride)
1 error, 0 warnings, 0 informations 

Como corrijo isso? Observação: sei que posso remover a dica de tipo completamente. Quero atribuir a ela o tipo correto.

Estou usando Python 3.13.3 e direitos autorais 1.1.400.

O MWE abaixo produz um gráfico como este:

Os rótulos das linhas, X, Y, Z, se sobrepõem ao lado direito do gráfico de barras de forma feia. Gostaria que fossem movidos mais para a direita, deixando uma pequena margem entre o gráfico e a tabela. A documentação de matplotlib.pyplot.table não possui nenhuma locopção que permita isso. O bboxargumento pode permitir, mas parece que seria necessário tentar e errar com diferentes caixas delimitadoras para que isso funcionasse.

Existe uma maneira de deixar isso mais claro?

import matplotlib.pyplot as plt
import seaborn as sns

plt.figure(figsize=(9, 5), dpi=300)
ax = sns.barplot(
    x = range(1, 3),
    y = [15,30],
    legend=False,
)
plt.table(cellText=['A','B','C'], rowLabels=['X','Y','Z'], colWidths=[0.15], loc='right')
plt.show()

Eu uso o seguinte código para criar subclasses da classe G e passar a elas o tipo de modelo que elas devem produzir.

from typing import TypeVar, Type


class A:
    @classmethod
    def model_validate(cls):
        print('Done')


T = TypeVar('T', bound=A)


class G[T]:
    def __init__(self, model: Type[T]):
        self.model = model

    def func(self) -> None:
        print(self.model.model_validate())


G[A](A).func()

Isso funciona bem, mas o mypy dá este erro:

error: "type[T]" has no attribute "model_validate"  [attr-defined]

O que estou fazendo errado?

Estou executando uma consulta para verificar se algum registro contém um espaço em branco DateOfBirth, mas os dados retornados não são o que eu esperava.

Eu executei o seguinte:

SELECT TOP 5 DateOfBirth, *
FROM [MyDataBase].[dbo].[CustomerRecord] 
WHERE DateOfBirth = ''

Quando executo isso, meus resultados mostram linhas como esta:

O Information_SCHEMA.Columnsmostra que a coluna é definida como datee COLUMN_DEFAULTé NULLe IS_NULLABLEestá definido como YES.

Então por que ele não retorna linhas em branco?

Estou tentando saber a duração de um arquivo de vídeo distante (digamos mp4).

Eu já sei como obter a duração de um arquivo de vídeo local :

import xml.etree.ElementTree as eltt, subprocess as spr

def size_from_fn(file_name):
    size = eltt.fromstring(
        spr.run(["ffprobe",
            "-i", file_name,
            "-show_format", "-output_format", "xml"
            ], stdout = spr.PIPE, stderr = spr.STDOUT).stdout.decode()
        ).find("format").get("duration")
    return size

def size_from_fd(file_descriptor):
    size = eltt.fromstring(
        spr.run(["ffprobe",
            "-i", "pipe:0",
            "-show_format", "-output_format", "xml"
            ], stdin = file_descriptor, stdout = spr.PIPE, stderr = spr.STDOUT).stdout.decode()
        ).find("format").get("duration")
    return size

def size_from_data(file_name):
    size = eltt.fromstring(
        spr.run(["ffprobe",
            "-i", "pipe:0",
            "-show_format", "-output_format", "xml"
            ], input = data, stdout = spr.PIPE, stderr = spr.STDOUT).stdout.decode()
        ).find("format").get("duration")
    return size

Tudo funciona perfeitamente

Também sei como obter uma solicitação HTTP como um descritor de arquivo:

import requests as rq

def url_to_fd(url):
    req = rq.get(url, stream = True)
    return req.raw

Também funciona

Entretanto a combinação dos dois falha com a mensagem de ffprobe:Invalid data found when processing input

Não tenho ideia do porquê, só sei que o descritor de arquivo retornado da URL tem a diferença de não ser pesquisável (leitura unidirecional), mas substitui este método de um descritor de arquivo normal:

with open("test.mp4", "rb") as f:
    f.seek = None
    size_of_fd(f)

isso funciona e assim mostra que ffprobenão usa nenhuma busca

Isso também funciona, então não sei o que está acontecendo:

def get_duration(url):
    complete_data = url_to_fd(url).read()
    return size_of_data(complete_data)

Meu problema é que os arquivos de vídeo podem ser arbitrariamente grandes, então não posso me dar ao luxo de baixar o vídeo inteiro.

URL do vídeo de teste

Como posso criar uma apresentação do PowerPoint com apresentação em quarto, com dois gráficos lado a lado, e incluir texto descritivo na parte inferior de cada slide (como mostrado na captura de tela)? O problema é que o texto está aparecendo no segundo slide em vez de na parte inferior dos gráficos no mesmo slide.

---
title: "iris Presentation"
format: pptx
---
parts of the code are from: https://github.com/quarto-dev/quarto-cli/discussions/2403 
```{r, include=FALSE}
library(tidyverse)

# Create histogram for each species
spec_name <- unique(iris$Species)

make_hist <- function(spec) {
  iris |> 
    filter(Species == spec) |> 
    ggplot(aes(x = Petal.Length)) +
    geom_histogram(bins = 10, fill = "steelblue", color = "white") +
    labs(title = paste("Petal Length Histogram -", spec))
}

list_hist <- map(spec_name, make_hist)

# Create a second set of plots (random scatter plots)
make_random_plot <- function() {
  tibble(x = rnorm(50), y = rnorm(50)) |> 
    ggplot(aes(x, y)) +
    geom_point(color = "darkorange") +
    labs(title = "Random Scatter Plot")
}

list_random <- map(spec_name, ~ make_random_plot())

# Combine into a data frame
df <- tibble(spec = spec_name, 
             plot1 = list_hist, 
             plot2 = list_random)
```

```{r}
#| output: asis
res <- pmap_chr(df, \(spec, plot1, plot2) {
  knitr::knit_child(text = c(
    paste0("## ", spec, " - Summary"),
    
    "```{r}",
    "#| echo: false",
    "#| layout-ncol: 2",
    "plot1",
    "plot2",
    "```",
    
    "",
    
    paste("This slide shows the distribution of Petal Length for", spec,
          "alongside a comparison scatter plot of random values.")
  ), envir = environment(), quiet = TRUE)
})
cat(res, sep = '\n')
```

Saída desejada:

Estou usando uma variável env MY_VARque uso de$env/static/public

import { MY_VAR } from '$env/static/public';

export const myVar = MY_VAR === 'true';

Gostaria de simular isso em alguns testes, para suportar os dois cenários: MY_VARbuild true/ false. Mas não consigo. Estou usando o vitest.

Tentei configurar um arquivo simulado __mock__/env/static/public.tscom:

export const MY_VAR = 'false';

com vitest.config.ts:

export default defineConfig(({ mode }) => ({
    // ...
    resolve: {
        alias: {
            '$env/static/public': path.resolve(__dirname, '__mocks__/env/static/public')
        }
    }
}));

Também tentei algumas combinações de vi.mock, vi.hoisted, vi.spyOnmas não consegui fazer funcionar.

Como posso simular $env/static/publiccom vitest?

Ao testar o fluxo de ar com o pytest, recebi um erro.

# tests/conftest.py

import datetime
import pytest
from airflow.models import DAG

@pytest.fixture
def test_dag():
    return DAG(
        "test_dag",
        default_args={
            "owner": "airflow",
            "start_date": datetime.datetime(2025, 4, 5),
            "end_date": datetime.datetime(2025, 4, 6)
        },
        schedule=datetime.timedelta(days=1)
    )

# tests/test_instance_context.py

import datetime

from airflow.models import BaseOperator
from airflow.models.dag import DAG
from airflow.utils import timezone

class SampleDAG(BaseOperator):
    template_fields = ("_start_date", "_end_date")

    def __init__(self, start_date, end_date, **kwargs):
        super().__init__(**kwargs)
        self._start_date = start_date
        self._end_date = end_date
    
    def execute(self, context):
        context["ti"].xcom_push(key="start_date", value=self.start_date)
        context["ti"].xcom_push(key="end_date", value=self.end_date)
        return context


def test_execute(test_dag: DAG):
    task = SampleDAG(
        task_id="test",
        start_date="{{ prev_ds }}",
        end_date="{{ ds }}",
        dag=test_dag
    )

    task.run(
        start_date=test_dag.default_args["start_date"], 
        end_date=test_dag.default_args["end_date"]
    )

    expected_start_date = datetime.datetime(2025, 4, 5, tzinfo=timezone.utc)
    expected_end_date = datetime.datetime(2025, 4, 6, tzinfo=timezone.utc)
    assert task.start_date == expected_start_date
    assert task.end_date == expected_end_date

O código de teste foi aprovado, mas tenho um problema aqui.

tests/test_instance_context.py [2025-04-26T12:51:18.289+0000] {taskinstance.py:2604} INFO - Dependencies not met for <TaskInstance: test_dag.test manual__2025-04-05T00:00:00+00:00 [failed]>, dependency 'Task Instance State' FAILED: Task is in the 'failed' state.
[2025-04-26T12:51:18.303+0000] {taskinstance.py:2604} INFO - Dependencies not met for <TaskInstance: test_dag.test manual__2025-04-06T00:00:00+00:00 [failed]>, dependency 'Task Instance State' FAILED: Task is in the 'failed' state.   
.

Quero testar task.run para ver a diferença entre task.rune task.execute. quando passo variáveis ​​jinja, o airflow renderiza automaticamente as variáveis ​​pelo método run.

Então, eu quero ver prev_ds, ds, start_date, end_date renderizados com sucesso. Mas recebi um erro acima.