All perguntas(coding)

Não consigo encontrar isso explicitamente declarado em nenhuma documentação para validação de bean JSR303/JSR380 ( Jakarta Validation ), mas todos os campos aos quais você aplica validações precisam ser "essencialmente" tipos de dados simples e antigos (POD), como Strings, ints, Longs e outros?

Tentei aplicar um validador de expressão regular a um campo UUID, e tive um NoProviderFoundExceptionproblema. Eu contornei isso apenas alterando esse campo para a Stringe colocando o ônus de converter o campo em a no UUID(s) consumidor(es) dessa classe, mas há alguma maneira de criar um "provedor de validação de bean" personalizado mapeado para uma classe não-POD arbitrária para casos em que implementar uma solução alternativa não é tão simples?

Observação: java.util.UUID é uma classe serializável e, portanto, perfeitamente válida para incluir em um Bean.

Contexto: Tenho escrito um programa multithread que usa atomics extensivamente. Percebi que esses atomics são muito lentos, especialmente no ARM, porque o compilador inseriu muitas fences, às vezes até dentro de loops. Então, quero eliminar as desnecessárias usando ordens de memória.

Eu tropecei neste caso, mas não tenho certeza se é seguro usar uma carga relaxada ou não. Veja este exemplo simples de leitura de parâmetros:

typedef struct {
    big_struct Data;
    _Atomic bool bDataReadDone;
} worker_thread_parameter;

static int WorkerThreadFunction(void* Parameter) {
    // Read Data
    worker_thread_parameter* pWorkerParameter = Parameter;
    big_struct Data = pWorkerParameter->Data;

    // Notify that reading Data is done
    // Use release store to ensure Data is read before this.
    atomic_store_explicit(&pWorkerParameter->bDataReadDone, true, memory_order_release);
        
    // Do something with Data
}

int main() {
    thrd_t aWorkerThread[8];
    for (size_t i = 0; i < 8; ++i) {
        worker_thread_parameter WorkerParameter = { /* Data = something */, false };
        thrd_create(&aWorkerThread[i], WorkerThreadFunction, &WorkerParameter);

        // Wait for Data to be read
        // Use relaxed load because this thread doesn't read Data anymore,
        // so we don't need to synchronize with the flag.
        while (!atomic_load_explicit(&WorkerParameter.bDataReadDone, memory_order_relaxed));
    }
}

Ou este exemplo:

// Initialized before the threads are started
_Atomic bool bUsingData = true;
big_struct* pData = malloc(sizeof(*pData));

static int WorkerThread() {
    Use(pData);

    // Notify the cleaner thread to free Data
    // Use release store to ensure Data is used before this.
    atomic_store_explicit(&bUsingData, false, memory_order_release);
}

static int CleanerThread() {
    // Use relaxed load because this thread doesn't read Data anymore,
    // so we don't need to synchronize with the flag.
    while (atomic_load_explicit(bUsingData, memory_order_relaxed));
    free(pData);
}

E este exemplo:

_Atomic int X = 0;
_Atomic int Y = 0;

// Thread 1

atomic_store_explicit(&X, 99, memory_order_relaxed);
atomic_store_explicit(&Y, 1, memory_order_release);

// Thread 2

if (atomic_load_explicit(&Y, memory_order_relaxed)) {
    atomic_store_explicit(&X, 100, memory_order_relaxed);
    printf("%i", atomic_load_explicit(&X, memory_order_relaxed));
}

// Does thread 2 always prints 100?

Como você pode ver no meu aplicativo abaixo, eu faço a filtragem, mas recebo Aviso: Erro na ordem: o argumento 1 não é um vetor ao tentar filtrar meus dados com o widget.

library(shiny)
library(shinydashboard)
library(dplyr)
library(plotly)
library(DT)
library(zoo)
library(shinyWidgets)

# Sample data
sample_data <- tibble::tibble(
  keyword = c("closing costs", "competitive commission", "curb appeal", "expert negotiation", 
              "home inspection", "market analysis", "mortgage pre-approval", "open house", 
              "price reduction", "staging tips"),
  gmb_id = rep("43763", 10),
  date = seq.Date(from = as.Date("2025-03-10"), by = "1 day", length.out = 10),
  pin_count = rep(39, 10),
  gmb_return = runif(10, -0.05, 0.05),
  gmb_abs_return = abs(runif(10, -0.05, 0.05))
)

ui <- dashboardPage(
  dashboardHeader(title = "🔧 Toy Pin Volatility"),
  dashboardSidebar(
    sidebarMenu(
      menuItem("Pin Volatility per Keyword", tabName = "pin_tab", icon = icon("map-pin")),
      pickerInput(
        inputId = "selected_keywords_pins",
        label = "Select Keyword(s)",
        choices = unique(sample_data$keyword),
        selected = unique(sample_data$keyword)[1:3],
        multiple = TRUE,
        options = list(`actions-box` = TRUE)
      )
    )
  ),
  dashboardBody(
    tabItems(
      tabItem(
        tabName = "pin_tab",
        
        fluidRow(
          box(width = 12, DTOutput("volatility_table_pins"))
        )
      )
    )
  )
)

server <- function(input, output, session) {
  rolling_pins <- reactive({
    req(input$selected_keywords_pins)
    
    sample_data %>%
      filter(trimws(keyword) %in% trimws(input$selected_keywords_pins)) %>%
      arrange(keyword, gmb_id, date) %>%
      group_by(keyword, gmb_id) %>%
      mutate(
        rolling_volatility = zoo::rollapply(gmb_abs_return,
                                            width = 3,
                                            FUN = sd,
                                            fill = NA,
                                            align = "right")
      ) %>%
      ungroup() %>%
      na.omit()
  })
  
  
  output$volatility_table_pins <- renderDT({
    datatable(
      rolling_pins(),
      options = list(pageLength = 10, scrollX = TRUE),
      rownames = FALSE
    )
  })
}

shinyApp(ui, server)

O elemento section é exibido com uma função genérica na árvore de acessibilidade abaixo. Ao usar o elemento article, a árvore de acessibilidade atribui corretamente a ele a função de 'article'. Mas, para section, ele atribui a ele a função 'generic' em vez de 'section'. Por que ele não recebe a função 'section'?

https://isstatic.askoverflow.dev/bmpi7AMU.png

Tenho um programa Appscript que uso há muito tempo. Ele me envia um e-mail com um anexo. O anexo é uma planilha do Google que foi exportada para um formato xlsx.

De repente, estou recebendo o erro: Exceção: Serviço indisponível: Gmail

Eu uso isso cerca de 10 vezes por dia, então acho que não estou atingindo nenhum limite de frequência.

Aqui está um exemplo mínimo:

let spreadsheet = SpreadsheetApp.getActive();
let spreadsheetId = spreadsheet.getId();
let sheetName = spreadsheet.getActiveSheet().getName();

let sheetId = spreadsheet.getSheetByName(sheetName).getSheetId();
let url = `https://docs.google.com/spreadsheets/d/${spreadsheetId}/export?format=xlsx&gid=${sheetId}`;
let params = { method: "GET", headers: { "authorization": "Bearer " + ScriptApp.getOAuthToken() } };
let response = UrlFetchApp.fetch(url, params).getBlob().setName(sheetName);
let email = "[email protected]";

GmailApp.sendEmail(email, 'subject', '', {
  attachments: {
    fileName: 'filename.xlsx',
    content: response.getBytes(),
    mimeType: `application/xlsx`,
  }
});

Curiosamente, funciona se eu remover o anexo. Eu tentei com anexos e formatos diferentes também e todos retornam o mesmo erro. Eu também tentei no modo anônimo. Eu realmente apreciaria qualquer ajuda! Obrigado!

Gostaria que este script Python 3.10 (onde o pynputcódigo é parcialmente baseado nesta resposta ) entrasse no whileloop e ao mesmo tempo monitorasse as teclas pressionadas no teclado. Quando qé pressionado, gostaria que ele terminasse.

(Não conheço muito bem os threads, mas eles while loopprovavelmente devem ser executados no thread principal e o monitor de teclado deve ser executado em um thread filho e simultâneo).

#!/usr/bin/python3

import threading
import sys
from pynput import keyboard

def on_key_press(key):
    try:
        k = key.char
    except:
        k = key.name
    if k in ['q']:
        exit_time = True

exit_time = False

print("Press q to close.")

keyboard_listener = keyboard.Listener(on_press=on_key_press)
keyboard_listener.start()
keyboard_listener.join()

while not exit_time:
    sleep(1)

print("Goodbye")
sys.exit(0)

Em vez disso, ele fica travado em uma espera infinita depois de keyboard_listener.start(). Não sei se keyboard_listener.join()não roda de jeito nenhum ou se faz com que o programa trave.

No entanto, o whileloop não é executado. Se eu terminar o programa com Ctrl+C:

^CTraceback (most recent call last):
  File "/my/source/./file.py", line 22, in <module>
    keyboard_listener.join()
  File "/my/.local/lib/python3.10/site-packages/pynput/_util/__init__.py", line 295, in join
    super(AbstractListener, self).join(timeout, *args)
  File "/usr/lib/python3.10/threading.py", line 1096, in join
    self._wait_for_tstate_lock()
  File "/usr/lib/python3.10/threading.py", line 1116, in _wait_for_tstate_lock
    if lock.acquire(block, timeout):
KeyboardInterrupt

Estou trabalhando com Azure Fabric Data Pipelines. Gostaria de alterar a extensão de arquivo para .csv, mas está esmaecido e, portanto, não me deixa alterar a extensão. Alguém pode me informar onde alterar a extensão de arquivo, por favor?

No Azure Data Factory, ele não está esmaecido e, portanto, pode ser facilmente alterado para qualquer extensão que você desejar. Não sei por que está esmaecido aqui

Ao tentar recuperar um IHttpMetricsTagsFeature em um projeto ASP.NET Core 8, dentro de uma ação MVC, sempre recebo nulo, ou seja, o recurso não está disponível na requisição atual:

var filter = HttpContext.Features.Get<Microsoft.AspNetCore.Http.Features.IHttpMetricsTagsFeature>(); //null

O que preciso fazer para habilitá-lo?

Gostaria de executar groupby e aggregation sobre um dataframe onde a agregação une strings com o mesmo id. O df se parece com isso:

In [1]: df = pd.DataFrame.from_dict({'id':[1,1,2,2,2,3], 'name':['a','b','c','d','e','f']})
In [2]: df
Out[2]:
   id name
0   1    a
1   1    b
2   2    c
3   2    d
4   2    e
5   3    f

Eu tenho isso funcionando no Pandas assim:

def list_aggregator(x):
    return '|'.join(x)

df2 = pd.DataFrame.from_dict('id':[], 'name':[])
df2['id'] = df['id'].drop_duplicates()
df2['name'] = df['name'].groupby(df['id']).agg(list_aggregator).values

Produz:

In [26]: df2
Out[26]:
   id   name
0   1    a|b
2   2  c|d|e
5   3      f

Para Dask, meu entendimento (dos documentos ) é que você tem que dizer a Dask o que fazer para agregar dentro de chunks, e então o que fazer com esses chunks agregados. Em ambos os casos, eu quero fazer o equivalente a '|'.join(). Então:

ddf = dd.from_pandas(df, 2)
ddf2 = dd.from_pandas(pd.DataFrame.from_dict({'id':[],'name':[]}))
ddf2['id'] = ddf['id'].drop_duplicates()

dd_list_aggregation = dd.Aggregation(
    'list_aggregation',
    list_aggregator,  # chunks are aggregated into strings with 1 string per chunk
    list_aggregator,  # per-chunk strings are aggregated into a single string per id
)

ddf2['name'] = ddf['name'].groupby(ddf['id']).agg(dd_list_aggregation).values

O resultado esperado é o acima (ou, na verdade, nada, já que ainda não chamei ddf2.compute()), mas recebo este erro:

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
File ~/miniconda3/envs/test/lib/python3.10/site-packages/dask_expr/_core.py:446, in Expr.__getattr__(self, key)
    445 try:
--> 446     return object.__getattribute__(self, key)
    447 except AttributeError as err:

File ~/miniconda3/envs/test/lib/python3.10/functools.py:981, in cached_property.__get__(self, instance, owner)
    980 if val is _NOT_FOUND:
--> 981     val = self.func(instance)
    982     try:

File ~/miniconda3/envs/test/lib/python3.10/site-packages/dask_expr/_groupby.py:206, in GroupByApplyConcatApply._meta_chunk(self)
    205 meta = meta_nonempty(self.frame._meta)
--> 206 return self.chunk(meta, *self._by_meta, **self.chunk_kwargs)

File ~/miniconda3/envs/test/lib/python3.10/site-packages/dask/dataframe/groupby.py:1200, in _groupby_apply_funcs(df, *by, **kwargs)
   1199 for result_column, func, func_kwargs in funcs:
-> 1200     r = func(grouped, **func_kwargs)
   1202     if isinstance(r, tuple):

File ~/miniconda3/envs/test/lib/python3.10/site-packages/dask/dataframe/groupby.py:1276, in _apply_func_to_column(df_like, column, func)
   1275 if column is None:
-> 1276     return func(df_like)
   1278 return func(df_like[column])

Cell In[88], line 2
      1 def dd_list_aggregator(x):
----> 2     return '|'.join(x[1])

File ~/miniconda3/envs/test/lib/python3.10/site-packages/pandas/core/base.py:245, in SelectionMixin.__getitem__(self, key)
    244     raise KeyError(f"Column not found: {key}")
--> 245 ndim = self.obj[key].ndim
    246 return self._gotitem(key, ndim=ndim)

AttributeError: 'str' object has no attribute 'ndim'

During handling of the above exception, another exception occurred:

RuntimeError                              Traceback (most recent call last)
Cell In[96], line 1
----> 1 ddf2['name'] = ddf['name'].groupby(ddf['id']).agg(dd_list_aggregation).values

File ~/miniconda3/envs/test/lib/python3.10/site-packages/dask_expr/_groupby.py:1907, in GroupBy.agg(self, *args, **kwargs)
   1906 def agg(self, *args, **kwargs):
-> 1907     return self.aggregate(*args, **kwargs)

File ~/miniconda3/envs/test/lib/python3.10/site-packages/dask_expr/_groupby.py:1891, in GroupBy.aggregate(self, arg, split_every, split_out, shuffle_method, **kwargs)
   1888 if arg == "size":
   1889     return self.size()
-> 1891 return new_collection(
   1892     GroupbyAggregation(
   1893         self.obj.expr,
   1894         arg,
   1895         self.observed,
   1896         self.dropna,
   1897         split_every,
   1898         split_out,
   1899         self.sort,
   1900         shuffle_method,
   1901         self._slice,
   1902         *self.by,
   1903     )
   1904 )

File ~/miniconda3/envs/test/lib/python3.10/site-packages/dask_expr/_collection.py:4440, in new_collection(expr)
   4438 def new_collection(expr):
   4439     """Create new collection from an expr"""
-> 4440     meta = expr._meta
   4441     expr._name  # Ensure backend is imported
   4442     return get_collection_type(meta)(expr)

File ~/miniconda3/envs/test/lib/python3.10/functools.py:981, in cached_property.__get__(self, instance, owner)
    979 val = cache.get(self.attrname, _NOT_FOUND)
    980 if val is _NOT_FOUND:
--> 981     val = self.func(instance)
    982     try:
    983         cache[self.attrname] = val

File ~/miniconda3/envs/test/lib/python3.10/site-packages/dask_expr/_groupby.py:432, in GroupbyAggregation._meta(self)
    430 @functools.cached_property
    431 def _meta(self):
--> 432     return self._lower()._meta

File ~/miniconda3/envs/test/lib/python3.10/functools.py:981, in cached_property.__get__(self, instance, owner)
    979 val = cache.get(self.attrname, _NOT_FOUND)
    980 if val is _NOT_FOUND:
--> 981     val = self.func(instance)
    982     try:
    983         cache[self.attrname] = val

File ~/miniconda3/envs/test/lib/python3.10/site-packages/dask_expr/_reductions.py:425, in ApplyConcatApply._meta(self)
    423 @functools.cached_property
    424 def _meta(self):
--> 425     meta = self._meta_chunk
    426     aggregate = self.aggregate or (lambda x: x)
    427     if self.combine:

File ~/miniconda3/envs/test/lib/python3.10/site-packages/dask_expr/_core.py:451, in Expr.__getattr__(self, key)
    447 except AttributeError as err:
    448     if key.startswith("_meta"):
    449         # Avoid a recursive loop if/when `self._meta*`
    450         # produces an `AttributeError`
--> 451         raise RuntimeError(
    452             f"Failed to generate metadata for {self}. "
    453             "This operation may not be supported by the current backend."
    454         )
    456     # Allow operands to be accessed as attributes
    457     # as long as the keys are not already reserved
    458     # by existing methods/properties
    459     _parameters = type(self)._parameters

RuntimeError: Failed to generate metadata for DecomposableGroupbyAggregation(frame=df['name'], arg=<dask.dataframe.groupby.Aggregation object at 0x7f052960b850>, observed=False, split_out=1). This operation may not be supported by the current backend.

Meu pensamento é que objetos numéricos são esperados, mas o backend é o pandas, então manipulações de strings devem ser possíveis, certo?

Tenho o seguinte dataframe:

import pandas as pd
d = {'Name': ['DataSource', 'DataSource'], 'DomainCode': ['Pr', 'Gov'], 'DomainName': ['Private', 'Government']}
df = pd.DataFrame(data=d)

Então o dataframe é o seguinte:

         Name DomainCode  DomainName
0  DataSource         Pr     Private
1  DataSource        Gov  Government

Preciso agrupá-lo pelo nome para receber duas listas:

         Name DomainCode    DomainName
0  DataSource [Pr, Gov]     [Private, Government]

Eu entendo como fazer isso para uma única coluna:

df = df.groupby("Name")["DomainCode"].apply(list).reset_index()

quando eu recebo

           Name DomainCode
0  A_DataSource  [GOV, PR]

mas não consigo adicionar a segunda coluna lá, não importa o que eu tenha tentado. Como fazer isso?

Outra questão é que a lista retornada pelo comando anterior não é uma lista, pois tem comprimento 1, e não 2.