All perguntas(coding)

Preciso construir um Axum Body a partir de um leitor OpenDAL, mas não consigo encontrar nenhuma maneira de fazer isso. Alguém sabe como fazer? Código de exemplo:

use axum::body::Body;
use opendal::{services, Operator};
use http_body_util::StreamBody;

async fn to_body() -> Body {
    let op = Operator::new(services::Fs::default().root("./")).unwrap().finish();
    let reader = op.reader("../Cargo.toml").await.unwrap();
    let stream = reader.into_stream(..).await.unwrap();

    // stream implements futures_core::stream::Stream so I expected this to work, but it doesn't:
    // let body = Body::from_stream(stream);

    // I can build a StreamBody but then I fail to create a Body from it
    let stream_body = StreamBody::new(stream).into();

    // Now I am not able to convert the stream_body to a Body
}

Estou tentando criar e salvar entradas do KeePass usando o pykeepass e salvando um arquivo .txt como anexo. No entanto, recebo um erro de digitação:

Traceback (most recent call last):
  File "c:\Users\Simplicissimus\Documents\coding\directory\attachment.py", line 15, in <module>
    entry.add_attachment('attachment.txt', f.read())
    ~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "C:\Users\Simplicissimus\AppData\Local\Programs\Python\Python313\Lib\site-packages\pykeepass\entry.py", line 163, in add_attachment
    E.Key(filename),
    ~~~~~^^^^^^^^^^
  File "src\\lxml\\builder.py", line 219, in lxml.builder.ElementMaker.__call__
TypeError: bad argument type: bytes(b'Lorem Ipsum bla bla bla\r\n')
(base) PS C:\Users\Simplicissimus\Documents\coding\directory> 

Meu exemplo mínimo reproduzível é:

from pykeepass import PyKeePass

kp = PyKeePass('testDatabase.kdbx', password='passwort')

generalGroup = kp.find_groups(name='General',first=True)
entry = kp.add_entry(
    generalGroup,  
    title='title',  
    username='username',
    password= 'password',
)

with open('loremipsum.txt', 'rb') as f:
    entry.add_attachment('attachment.txt', f.read())

kp.save()

(Todos os arquivos estão no mesmo diretório, o arquivo loremipsum.txtcontém a linha: "Lorem Impsum bla bla bla")

Como faço para converter o conteúdo de um arquivo .txt para bytes?

Estou usando o pykeepass versão: 4.1.0.post1, Keepass versão 2.58 e Python 3.13.

Estou brincando com os operadores pipe |e ampersand &, bem como com as funções internas .gt()and para ver como eles funcionam juntos..lt()

Estou olhando para uma coluna em um DataFrame com valores de 0,00 a 1,00.

Posso usar os operadores >, <, e juntos e não encontro problemas, o mesmo com o uso de , , e . No entanto, se tento encadear, o resultado é diferente.&.gt().lt()&.gt().lt()

No meu exemplo, estou usando .gt(0.7).lt(0.9), mas isso produz valores <=0,7. Se eu alterar a ordem para .lt(0.9).gt(0.7), obtenho valores <=0,9.

Posso sempre escrever assim df['column'].gt(0.7)&df['column'].lt(0.9), só queria saber se existe uma maneira de encadear .gt().lt()

Tenho certeza de que isso é um erro meu, mas como o script funciona, não sei se é um problema que vai aparecer em algum momento. Tenho 11 abas, e o script percorrerá as primeiras 9 abas, ocultando as linhas sem dados e, em seguida, definirá o cursor de cada aba para B4, exceto as abas 10 e 11, que serão definidas para A1. Mas há uma chave vermelha e não sei como corrigi-la. Uma está no final da primeira linha, a correspondente é a linha com }); Obrigado pela ajuda.

       function onOpen() {
  
  SpreadsheetApp.getActive().getSheets().forEach(function (s,index,array) {  //for each sheet
  
  if(index<9){ //if sortable page, not maps or docs
  var nameOfSheet= array[index].getName()
  var ssa = SpreadsheetApp.getActive().getSheetByName(nameOfSheet) //get active sheet
  var max = ssa.getMaxRows()//max rows for this sheet
  var last = ssa.getLastRow() //last row with data
  ssa.hideRows(last+1, max-last)
  }

  if(index>8){
      s.setActiveSelection("A1"); //set active cell for sheet to A1 if map or documentation sheet
    SpreadsheetApp.flush(); // Force this update to happen before moving to next sheet
    }else{
      s.setActiveSelection("B4"); //set active cell for sheet to B4 for other sheets
    SpreadsheetApp.flush(); // Force this update to happen before moving to next sheet
  }
  
  });
  var sheet = SpreadsheetApp.getActive().getSheetByName('Active(Date)'); //set back to first sheet
  var range = sheet.getRange('B4'); //put cursor on search box
  range.activate(); 
}

Estou trabalhando com uma configuração de Diferença em Diferenças (DiD) escalonada em R usando o didpacote, onde as unidades são tratadas em momentos diferentes e algumas nunca são tratadas (por exemplo, grupo de controle). Aqui está o código que estou usando:

att_results <- att_gt(
    yname = "ln_Pris",
    tname = "Year",
    idname = "id",
    gname = "treatment_year",
    data = clean_data,
    panel = FALSE
)

Algumas unidades nos meus dados nunca são tratadas , então a sua treatment_yearé NA. Quando executo isso, parece que essas unidades estão sendo descartadas da estimativa — presumo que gnameseja NApara o grupo de controle.

No entanto, preciso incluir as unidades nunca tratadas como grupo de controle na análise DiD. Percebi que há um control_groupargumento em att_gt(), mas não sei como usá-lo nesta situação.

Pergunta:
Como posso incluir unidades nunca tratadas na estimativa? Preciso atribuir algo manualmente para gnameessas unidades ou a configuração é control_group = "never treated"suficiente?

Desde já, obrigado!

O problema

As pontuações de similaridade são quase as mesmas para textos que descrevem uma foto de um gato e de um cachorro (a foto é de um gato).

Cat similarity: tensor([[-3.5724]], grad_fn=<MulBackward0>)
Dog similarity: tensor([[-3.4155]], grad_fn=<MulBackward0>)

O código para o modelo CLIP

O código é baseado no ponto de verificação de openai/clip-vit-base-patch32 . A função encode_text recebe uma entrada bruta e a transforma em embeddings, que posteriormente são inseridos no método forward. Tenho certeza de que os nomes e tamanhos das camadas estão corretos, pois o ponto de verificação se ajusta ao modelo sem erros devido a camadas ausentes ou inesperadas.

class CLIP(nn.Module):
    def __init__(self, project_dim: int = 768, embed_dim: int = 512):
        super(CLIP, self).__init__()

        self.vision_model = ImageEncoder(project_dim = project_dim)
        self.text_model = TextEncoder(embed_dim = embed_dim)
        self.tokenizer = TorchTokenizer()
        
        self.logit_scale = nn.Parameter(torch.ones([]) * 0.7) 
        self.visual_projection = nn.Linear(project_dim, embed_dim, bias = False)
        self.text_projection = nn.Linear(embed_dim, embed_dim, bias = False)

        self.vision_model.eval()
        self.text_model.eval()

    def forward(self, image: torch.Tensor, text_embed: torch.Tensor) -> torch.Tensor:

        " Compute the relationship between image and text  "

        # get fixed size to comply with the checkpoint position_embeddings nn.Embedding(50, embed_dim)
        image = Resize(size=(224, 224))(image)

        image_features = self.vision_model(image)

        # projections
        text_features = self.text_projection(text_embed)
        image_features = self.visual_projection(image_features)
        
        # normalization
        text_features = F.normalize(text_features, dim = -1)
        image_features = F.normalize(image_features, dim = -1)

        logits = self.logit_scale.exp() * (image_features @ text_features.t())

        return logits
    
    def encode_text(self, input_ids, attention_mask = None):
        """ Tokenize (if needed) and encode texts, returning embeddings and mask. Function for ConditionalPromptNorm """

        # tokenize strings if raw text passed
        if attention_mask is None:
            input_ids, attention_mask = self.tokenizer.tokenize(input_ids)
        
        # ensure batch dim
        if input_ids.dim() == 1:
            input_ids = input_ids.unsqueeze(0)

        with torch.no_grad():
            text_emb = self.text_model(input_ids.long(), attention_mask)

        return text_emb

O código para o codificador de texto

Verifiquei se a obtenção do token EOS funciona corretamente. Além disso, os tipos de camadas, como nn.Embedding e nn.Parameter, estão corretos para cada camada, pois entraria em conflito com o ponto de verificação se não fossem do mesmo tipo.

class TextEncoder(nn.Module):
    def __init__(self, embed_dim: int = 512):
        super(TextEncoder, self).__init__()

        vocab_size = 49408

        self.embeddings = nn.Module()
        self.embeddings.token_embedding = nn.Embedding(vocab_size, embed_dim)
        # tokenizer's context_length must be set to 77 tokens
        self.embeddings.position_embedding = nn.Embedding(77, embed_dim) # 77 = context length

        self.encoder = Encoder(embed_size = embed_dim)

        self.final_layer_norm = nn.LayerNorm(embed_dim)

    def forward(self, text: torch.Tensor, attention_mask: torch.Tensor):

        x = self.embeddings.token_embedding(text.long())

        #                       seq_length
        positions = torch.arange(x.size(1))
        pos_embed = self.embeddings.position_embedding(positions)

        x += pos_embed.to(x.dtype).to(x.device)

        # obtain text embeddings
        x = x.permute(1, 0, 2)
        x = self.encoder(x, attention_mask)
        x = x.permute(1, 0, 2)

        # ensure batch dim
        if x.dim() == 2: x = x.unsqueeze(0)
        if attention_mask.dim() == 1: attention_mask = attention_mask.unsqueeze(0)

        # for each batch, get the last token (eos)
        x = x[torch.arange(x.size(0)), text.argmax(dim = -1)]

        return self.final_layer_norm(x)

A classe de atenção é de https://github.com/openai/CLIP/blob/main/clip/model.py#L58 com uma pequena modificação para permitir atenção própria e combinada (x e x[:1]).

O Codificador

Verifiquei se o código do tokenizador funciona corretamente. O MLP é o mesmo do código original do CLIP. Duas camadas lineares com proporção de 4 e um GELU no meio.

class EncoderLayer(nn.Module):
    def __init__(self, embed_size: int = 768, ratio: int = 4, num_heads: int = 8):
        super().__init__()

        self.layer_norm1 = nn.LayerNorm(embed_size)
        self.layer_norm2 = nn.LayerNorm(embed_size)
        self.mlp = MLP(embed_size = embed_size, ratio = ratio)

        self.self_attn = AttentionPool2d(num_heads = num_heads, embed_dim = embed_size)

    def forward(self, x: torch.Tensor, src_pad_key = None):

        x = self.layer_norm1(x)
        
        if src_pad_key is not None: attn_out = self.self_attn(x, src_pad_key = src_pad_key, use_self_attention = True)
        else: attn_out = self.self_attn(x)

        # normalize and apply residual connections
        x += attn_out
        x = self.layer_norm2(x)
        x += self.mlp(x)

        return x

class Encoder(nn.Module):
    def __init__(self, embed_size = 768):
        super().__init__()

        self.layers = nn.ModuleList([EncoderLayer(embed_size = embed_size) for _ in range(12)])

    def forward(self, x: torch.Tensor, attention_mask = None):

        if attention_mask is not None:
            src_key_mask = attention_mask == 0
            if src_key_mask.dim() == 1: src_key_mask = src_key_mask.unsqueeze(0)

            for layer in self.layers:
                x = layer(x, src_key_mask)
        
        else:
            for layer in self.layers:
                x = layer(x)

        return x

Estou usando --mount=type=cacheo DockerfilePIP para armazenar em cache os pacotes entre as compilações, mas isso não parece afetar a velocidade da compilação. Eu esperava que o PIP reutilizasse os pacotes em cache e evitasse baixá-los novamente, mas cada compilação leva o mesmo tempo.

Aqui está a parte relevante do meu Dockerfile:

FROM python:3.13-slim AS compile-image

RUN python -m venv /opt/venv
ENV PATH="/opt/venv/bin:$PATH"

RUN pip install --no-cache-dir --upgrade pip


# Final image
FROM python:3.13-slim
ENV PATH="/opt/venv/bin:$PATH"

COPY --from=compile-image /opt/venv /opt/venv

WORKDIR /app
ENV HOME=/app

COPY . .

RUN --mount=type=cache,mode=0755,target=/root/.cache/pip \
    pip install -e .

Este cache não deveria baixar pacotes e reutilizá-los em compilações subsequentes? Qual poderia ser o motivo de não estar funcionando como esperado?

Estou tentando automatizar uma tarefa por meio do console do Firefox nas Ferramentas do Desenvolvedor executando algum código jQuery.

Primeiro, um exemplo dos nós pelos quais preciso passar. Observe os comentários em linha. Há nós em que o botão tem um intervalo que não contém a palavra "Ciclismo" e deve ser ignorado.

<div class="ActivityListItem_activityType__qQkN4">
    <button>
        <span class="ActivityListItem_activityTypeText__jWs2o">Cycling</span>
        <span class="InlineEditDropdown_iconPointerDown__0bK4V ActivityListItem_isHidden__2pG6N"><i
                class="icon-pointer-down"></i>
        </span>
    </button>

    <!-- dynamically added after clicking above button -->
    <ul class="InlineEditDropdown_dropdownContainer__E5M6g" role="menu">
        <!-- omitted children li -->
        <li class="InlineEditDropdown_dropdownItem__WkY6H null null" tabindex="0"><a href="#" role="menuitem">Mountain Biking</a></li>
        <!-- omitted children li -->
    </ul>
</div>

Os passos que parecem precisar ser replicados:

1. clique no botão, que dispara um evento e faz uma lista aparecer
2. na lista, clique na opção desejada que dispara outro evento

O script que estou executando no console:

var script = document.createElement('script');
script.src = 'https://code.jquery.com/jquery-3.6.0.min.js';
document.head.appendChild(script);

var x = 0;
//select using start of the class name
$('div[class^="ActivityListItem_activityType"]').each(function(x){
    //alert("here..."+x); //outputs incremented value
    
    //click to make the list appear
    $(this).children('button span:contains("Cycling")').click();
    
    //click the right li to launch event
    $(this).children('ul li a:contains("Mountain Biking")').click();
});

Nenhum erro, mas também não vejo muita coisa acontecendo (além do alerta quando está habilitado).

Supondo que meus seletores estejam errados? Talvez eu esteja entendendo errado como usar .children()?

Ao escrever um script independente de DOM/Node, é útil definir a typespropriedade do tsconfigarquivo como [], para garantir que você não use acidentalmente nenhum global específico do ambiente.

Infelizmente, consoleé considerado um fenômeno global.

Até onde sei, não há valor que possa ser adicionado liba isso consolesem também incluir um monte de outras coisas.

Existe uma maneira de fazer isso apenas com o tsconfig? Ou terei que criar um d.tsarquivo que descreva o console e usá-lo?

Dei uma olhada na documentação da biblioteca em https://www.typescriptlang.org/tsconfig/#lib , mas não vejo nada lá (ou no código-fonte relacionado) que pareça definir uma Consoleinterface.

Contexto

Estou desenvolvendo um aplicativo de mensagens para iOS com a necessidade de gerenciar com precisão a contagem de emblemas para mensagens não lidas. Quando o aplicativo está em execução (em primeiro ou segundo plano), posso consultar o servidor para obter a contagem exata de mensagens não lidas dentro didReceiveRemoteNotificationdos userNotificationCenter(_:willPresent:)manipuladores.

Problema

No entanto, estou com dificuldades para gerenciar a contagem de emblemas quando o aplicativo é completamente encerrado. Nesse caso, preciso contar com uma NotificationServiceextensão para incrementar a contagem de emblemas. Minha preocupação é: como minha NotificationServiceextensão pode detectar se o aplicativo principal está em execução? Quero evitar inconsistências na contagem de emblemas onde:

• Se o aplicativo principal estiver em execução, ele deverá lidar com contagens de emblemas por meio de consultas ao servidor
• Se o aplicativo principal for encerrado, os NotificationServiceemblemas devem ser incrementados

Pergunta

Qual é a maneira mais confiável para a NotificationServiceextensão detectar o estado de execução do aplicativo principal e quais mecanismos de sincronização devo implementar para evitar disputas de dados ao atualizar contagens de emblemas nesses dois contextos?