All perguntas(coding)

Nesta URL: http://estatisticas.cetip.com.br/astec/series_v05/paginas/lum_web_v05_template_informacoes_di.asp?str_Modulo=completo&int_Idioma=2&int_Titulo=6&int_NivelBD=2/

Estou tentando clicar nas caixas de seleção e no botão calcular, mas não consigo.

Eu tentei o seguinte:

# checkbox
WebDriverWait(driver,5).until(EC.element_to_be_clickable((By.XPATH,'//input[@name="chk_M1"]'))).click()

# button
driver.find_element_by_xpath('//a[@class="button" and contains(text(),"Calculate")]')

Eu consigo selecionar corretamente os elementos quando pesquiso nos elementos ao inspecionar. Eu tentei esperar, mas ainda não consigo selecionar.

Caixa de seleção:

Botão:

Erro:

selenium.common.exceptions.NoSuchElementException: Message: no such element: Unable to locate element: {"method":"xpath","selector":"//a[@class="button" and contains(text(),"Calculate")]"}

Atualmente, estou usando

     val response = supabase.from("schedules")
                    .select()
                    { filter {eq("user_id", userId)   } }  // Filtering by the user_id

para filtrar pelo uder_id. No entanto, também quero filtrar por defualt (que é um valor bool) depois disso. Não consigo encontrar nenhuma documentação sobre isso. Alguém pode me dar algumas sugestões?

Eu tentei coisas como

val response = supabase.from("schedules")
                    .select()
                    { filter {eq("user_id", userId),eq("defualt", "TRUE")   } }

e

val response = supabase.from("schedules")
                    .select()
                    { filter {eq("user_id", userId) } }.select()
                    { filter {eq("defualt", "TRUE")   } }

mas nenhuma delas funciona. Não consigo encontrar nenhuma documentação sobre isso. Alguém pode me dar algumas sugestões?

Criei um aplicativo React pronto para uso com ASP.NET Core Web API (.NET 9, VS 2022 17.13.5).

Em versões anteriores (.NET 6), eu obtinha uma ClientAppsolução aninhada no backend e, quando publicava, tudo isso era incluído.

Agora eu tenho:

• MeuApp.Servidor
• meuaplicativo.cliente

Quando publico MyApp.Server, o aplicativo de backend é implantado, mas o frontend não.

Os logs locais (pasta) ou do servidor mostram o seguinte aviso:

aviso: Microsoft.AspNetCore.StaticFiles.StaticFileMiddleware[16]
O WebRootPath não foi encontrado: ..
\MyApp.Server\bin\Release\net9.0\publish\wwwroot. Arquivos estáticos podem estar indisponíveis.

Mas isso é esperado, já que o site não está lá.

Alguém teve um problema semelhante? O .NET 6 funcionou imediatamente.

Qualquer ajuda será muito apreciada,
David

Tenho este conjunto de dados em R:

set.seed(123)

num_patients <- 50
patient_ids <- rep(1:num_patients, each = sample(2:10, num_patients, replace = TRUE))
n_visits <- length(patient_ids)

start_date <- as.Date("2022-01-01")
end_date <- as.Date("2023-12-31")
visit_dates <- sample(seq(start_date, end_date, by = "day"), n_visits, replace = TRUE)

results <- sample(c("miss", "attend"), n_visits, replace = TRUE, prob = c(0.25, 0.75))

patient_visits <- data.frame(
  patient_id = patient_ids,
  visit_date = sort(visit_dates[order(patient_ids)]),
  result = results
)

head(patient_visits)

Este conjunto de dados mostra como diferentes pacientes compareceram ou faltaram às consultas:

 patient_id visit_date result
1          1 2022-01-05   miss
2          1 2022-01-13 attend
3          1 2022-01-20 attend
4          1 2022-01-24 attend
5          2 2022-01-26 attend
6          2 2022-02-03   miss

Quero responder a seguinte pergunta:

- Para pacientes que têm exatamente 1 consulta: qual foi a taxa de faltas na primeira consulta?

- Para pacientes que têm exatamente 2 consultas: qual foi a taxa de faltas na primeira consulta? qual foi a taxa de faltas na segunda consulta?

- Para pacientes que têm exatamente 3 consultas: qual foi a taxa de faltas na primeira consulta? qual foi a taxa de faltas na segunda consulta? qual foi a taxa de faltas na terceira consulta?

- Para pacientes que têm exatamente 4 consultas: qual foi a taxa de faltas na primeira consulta? qual foi a taxa de faltas na segunda consulta? qual foi a taxa de faltas na terceira consulta? qual foi a taxa de faltas em todas as outras consultas (agrupadas em uma)?

Tentei fazer isso manualmente para cada combinação:

patient_visits <- patient_visits[order(patient_visits$patient_id, patient_visits$visit_date), ]
patient_visits$appt_seq <- unlist(tapply(patient_visits$patient_id, patient_visits$patient_id, FUN = function(x) 1:length(x)))

appt_counts <- table(patient_visits$patient_id)

patients_with_1_appt <- as.numeric(names(appt_counts[appt_counts == 1]))
patients_with_2_appt <- as.numeric(names(appt_counts[appt_counts == 2]))
patients_with_3_appt <- as.numeric(names(appt_counts[appt_counts == 3]))
patients_with_4_appt <- as.numeric(names(appt_counts[appt_counts == 4]))

results_df <- data.frame(
  total_appointments = numeric(),
  appointment_number = character(),
  miss_rate = numeric(),
  stringsAsFactors = FALSE
)

visits_1 <- patient_visits[patient_visits$patient_id %in% patients_with_1_appt, ]
miss_rate_1 <- mean(visits_1$result == "miss")
results_df <- rbind(results_df, data.frame(
  total_appointments = 1,
  appointment_number = "1",
  miss_rate = miss_rate_1
))

visits_2 <- patient_visits[patient_visits$patient_id %in% patients_with_2_appt, ]
miss_rate_2_first <- mean(visits_2[visits_2$appt_seq == 1, "result"] == "miss")
miss_rate_2_second <- mean(visits_2[visits_2$appt_seq == 2, "result"] == "miss")
results_df <- rbind(results_df, data.frame(
  total_appointments = c(2, 2),
  appointment_number = c("1", "2"),
  miss_rate = c(miss_rate_2_first, miss_rate_2_second)
))

visits_3 <- patient_visits[patient_visits$patient_id %in% patients_with_3_appt, ]
miss_rate_3_first <- mean(visits_3[visits_3$appt_seq == 1, "result"] == "miss")
miss_rate_3_second <- mean(visits_3[visits_3$appt_seq == 2, "result"] == "miss")
miss_rate_3_third <- mean(visits_3[visits_3$appt_seq == 3, "result"] == "miss")
results_df <- rbind(results_df, data.frame(
  total_appointments = c(3, 3, 3),
  appointment_number = c("1", "2", "3"),
  miss_rate = c(miss_rate_3_first, miss_rate_3_second, miss_rate_3_third)
))

visits_4 <- patient_visits[patient_visits$patient_id %in% patients_with_4_appt, ]
miss_rate_4_first <- mean(visits_4[visits_4$appt_seq == 1, "result"] == "miss")
miss_rate_4_second <- mean(visits_4[visits_4$appt_seq == 2, "result"] == "miss")
miss_rate_4_third <- mean(visits_4[visits_4$appt_seq == 3, "result"] == "miss")
miss_rate_4_other <- mean(visits_4[visits_4$appt_seq > 3, "result"] == "miss")
results_df <- rbind(results_df, data.frame(
  total_appointments = c(4, 4, 4, 4),
  appointment_number = c("1", "2", "3", "4+"),
  miss_rate = c(miss_rate_4_first, miss_rate_4_second, miss_rate_4_third, miss_rate_4_other)
))

Existe uma maneira mais fácil de fazer isso no R básico?

Tenho uma função SubOrchestrator que chama as seguintes Funções de Atividade:

    public async Task GetTransitiveMembers(IDurableOrchestrationContext context, GroupMembershipRequest request)
    {
        if (!context.IsReplaying) _ = _log.LogMessageAsync(new LogMessage { RunId = request.RunId, Message = $"Getting results from 1st page" });
        var nextPageUrl = await context.CallActivityAsync<string>(nameof(MembersReaderFunction), new MembersReaderRequest { RunId = request.RunId, GroupId = request.SourceGroup.ObjectId, TargetGroupId = request.GroupId, CurrentPart = request.CurrentPart });
    
    
        while (!string.IsNullOrEmpty(nextPageUrl))
        {
            if (!context.IsReplaying) _ = _log.LogMessageAsync(new LogMessage { RunId = request.RunId, Message = $"Getting results from next page url: {nextPageUrl}" });
            var oldNextPageUrl = nextPageUrl;              
            nextPageUrl = await context.CallActivityAsync<string>(nameof(SubsequentMembersReaderFunction), new SubsequentMembersReaderRequest { RunId = request.RunId, NextPageUrl = nextPageUrl, GroupId = request.SourceGroup.ObjectId, TargetGroupId = request.GroupId, CurrentPart = request.CurrentPart })
        }
    }

Funções de atividade:

    [FunctionName(nameof(MembersReaderFunction))]
    public async Task<string> GetMembersAsync([ActivityTrigger] MembersReaderRequest request)
    {
        await _log.LogMessageAsync(new LogMessage { Message = $"{nameof(MembersReaderFunction)} function started", RunId = request.RunId }, VerbosityLevel.DEBUG);
        _calculator.RunId = request.RunId;
        var response = await _calculator.GetFirstTransitiveMembersPageAsync(request.GroupId, request.RunId);
        response.Users = new List<AzureADUser> { new AzureADUser { UserPrincipalName = "a" } };
        var fileName = $"/{request.TargetGroupId}/{request.RunId}_GroupMembership_{request.CurrentPart}.json";
        using (MemoryStream logEntryStream = new MemoryStream())
        {
            await JsonSerializer.SerializeAsync(logEntryStream, response.Users);
            logEntryStream.Position = 0;
            await _blobStorageRepository.AppendDataToBlobAsync(logEntryStream, fileName);
        }
        await _log.LogMessageAsync(new LogMessage { Message = $"{nameof(MembersReaderFunction)} function completed", RunId = request.RunId }, VerbosityLevel.DEBUG);
        return response.NextPageUrl;
    }

    [FunctionName(nameof(SubsequentMembersReaderFunction))]
    public async Task<string> GetMembersAsync([ActivityTrigger] SubsequentMembersReaderRequest request)
    {
        await _log.LogMessageAsync(new LogMessage { Message = $"{nameof(SubsequentMembersReaderFunction)} function started", RunId = request.RunId }, VerbosityLevel.DEBUG);
        _calculator.RunId = request.RunId;
        var response = await _calculator.GetNextTransitiveMembersPageAsync(request.NextPageUrl);
        response.Users = new List<AzureADUser> { new AzureADUser { UserPrincipalName = "b" } };
        var fileName = $"/{request.TargetGroupId}/{request.RunId}_GroupMembership_{request.CurrentPart}.json";
        using (MemoryStream logEntryStream = new MemoryStream())
        {
            await JsonSerializer.SerializeAsync(logEntryStream, response.Users);
            logEntryStream.Position = 0;
            await _blobStorageRepository.AppendDataToBlobAsync(logEntryStream, fileName);
        }
        await _log.LogMessageAsync(new LogMessage { Message = $"{nameof(SubsequentMembersReaderFunction)} function completed", RunId = request.RunId }, VerbosityLevel.DEBUG);
        return response.NextPageUrl;
    }

Repositório BlobStorage:

    public async Task AppendDataToBlobAsync (MemoryStream logEntryStream, string logBlobName)
    {
        var appendBlobClient = _containerClient.GetAppendBlobClient(logBlobName);
    
        await appendBlobClient.CreateIfNotExistsAsync();
        logEntryStream.Position = 0;
    
        var maxBlockSize = appendBlobClient.AppendBlobMaxAppendBlockBytes;
        var bytesLeft = logEntryStream.Length;
        var buffer = new byte[maxBlockSize];
        while (bytesLeft > 0)
        {
            var blockSize = (int)Math.Min(bytesLeft, maxBlockSize);
            var bytesRead = await logEntryStream.ReadAsync(buffer.AsMemory(0, blockSize));
            await using (MemoryStream memoryStream = new MemoryStream(buffer, 0, bytesRead))
            {
                await appendBlobClient.AppendBlockAsync(memoryStream);
            }
            bytesLeft -= bytesRead;
        }
    }

Eu vejo o conteúdo no blob assim:

    [
        {
            "ObjectId": "00000000-0000-0000-0000-000000000000",
            "Mail": null,
            "UserPrincipalName": "a",
            "Properties": null,
            "MembershipAction": null,
            "SourceGroup": "00000000-0000-0000-0000-000000000000",
            "SourceGroups": null
        }
    ][
        {
            "ObjectId": "00000000-0000-0000-0000-000000000000",
            "Mail": null,
            "UserPrincipalName": "b",
            "Properties": null,
            "MembershipAction": null,
            "SourceGroup": "00000000-0000-0000-0000-000000000000",
            "SourceGroups": null
        }
    ][
        {
            "ObjectId": "00000000-0000-0000-0000-000000000000",
            "Mail": null,
            "UserPrincipalName": "b",
            "Properties": null,
            "MembershipAction": null,
            "SourceGroup": "00000000-0000-0000-0000-000000000000",
            "SourceGroups": null
        }
    ]

Deveria ser:

    [
        {
            "ObjectId": "00000000-0000-0000-0000-000000000000",
            "Mail": null,
            "UserPrincipalName": "a",
            "Properties": null,
            "MembershipAction": null,
            "SourceGroup": "00000000-0000-0000-0000-000000000000",
            "SourceGroups": null
        },
        {
            "ObjectId": "00000000-0000-0000-0000-000000000000",
            "Mail": null,
            "UserPrincipalName": "b",
            "Properties": null,
            "MembershipAction": null,
            "SourceGroup": "00000000-0000-0000-0000-000000000000",
            "SourceGroups": null
        },
        {
            "ObjectId": "00000000-0000-0000-0000-000000000000",
            "Mail": null,
            "UserPrincipalName": "b",
            "Properties": null,
            "MembershipAction": null,
            "SourceGroup": "00000000-0000-0000-0000-000000000000",
            "SourceGroups": null
        }
    ]

Como posso corrigir isso?

Já faz um tempo desde que o construtor abreviado foi introduzido, e ele é realmente útil. Agora eu posso escrever isto:

class Dog {
  constructor(
    public age: number,
    public weight: number,
  ) {}
}

em vez disso:

class Dog {
  public age: number
  public weight: number

  constructor(
    age: number,
    weight: number,
  ) {
    this.age = age
    this.weight = weight
  }
}

E funciona ainda melhor para classes mais complexas.

Gostaria de saber se há alguma abreviação para construtor de classe com parâmetros nomeados (usando destruição de objeto)? Acho que new Dog({age: 3, weight: 8})é muito mais claro do que new Dog(3, 8). Não há chance de perder as posições dos argumentos. Mas a definição de classe para isso parece realmente feia:

class Dog {
  // 1. declare properties
  public age: number
  public weight: number

  constructor({
    // 2. object destructing
    age,
    weight,
  }: {
    // 3. declare object type
    age: number,
    weight: number,
  }) {
    // 4. assign values
    this.age = age
    this.weight = weight
  }
}
// x4 duplicates, no DRY at all

É possível adicionar marcas de escala de retícula e coordenadas ao redor das bordas de um leafletgráfico? Algo como a captura de tela abaixo, mas com valores de lon/lat incluídos? Procurei online, mas não encontrei uma solução.

map <- leaflet() %>%
  addTiles() %>%
  setView(lng = -118.88, lat = 38.1341, zoom = 8) #|>
  #addCoordinates()
map

Tenho um pequeno aplicativo Kotlin que usa um banco de dados Supabase como backend. Tenho o problema de ter 2 relações nas tabelas que quero recuperar e não consigo encontrar uma solução para minha consulta.

Tenho uma tabela que contém itens, isso já é exibido no código fornecido abaixo. No entanto, essa tabela tem uma relação com uma tabela que contém categorias. Essa tabela de categorias tem um ID, um nome e um ID pai. Esse ID pai se refere a outra categoria que serve como a categoria principal. Gostaria de recuperar a subcategoria e a categoria principal com o item. Existe uma maneira de fazer isso em uma consulta simples?

Incluí um exemplo de consulta SQL que cobre o problema aqui

SELECT 
    a.name,
    c1.name AS sub_category, 
    c2.name AS main_category,
FROM "Item_Table" a
LEFT JOIN categories c1 ON a.category_id = c1.id
LEFT JOIN categories c2 ON c1.parent_id = c2.id;

Meu código Kotlin no aplicativo está atualizado, então:

@Composable
fun ItemsList() {
    var itemsList by remember { mutableStateOf<List<Item>>(listOf()) }
    LaunchedEffect(Unit) {
        withContext(Dispatchers.IO) {
            itemsList = supabase.from("Item_Table")
                .select().decodeList<Item>()
        }
    }
    LazyColumn {
        items(
            itemsList,
            key = { it.id },
        ) { item ->
            Text(
                item.name,
                modifier = Modifier.padding(8.dp),
            )
        }
    }
}

Estou com dificuldades para fazer um counter cache funcionar em um has_one :through e estou com um comportamento estranho. Quero ter um counter_cache no Companymodelo que armazene em cache o número de associados Location(through the BusinessUnitmodel).

Objetos:

class Company < ApplicationRecord
  has_many :business_units, class_name: :BusinessUnit, dependent: :destroy
  has_many :locations, through: :business_units, dependent: :destroy, counter_cache: :locations_count
end

class BusinessUnit < ApplicationRecord
  belongs_to :company, counter_cache: :locations_count
  has_many :locations, dependent: :destroy
end

class Location < ApplicationRecord
  belongs_to :business_unit
  has_one :company, through: :business_unit
end

Esquema:

ActiveRecord::Schema[7.1].define(version: 2025_04_03_203549) do
  enable_extension "plpgsql"

  create_table "business_units", force: :cascade do |t|
    t.string "name"
    t.bigint "company_id", null: false
    t.datetime "created_at", null: false
    t.datetime "updated_at", null: false
    t.index ["company_id"], name: "index_business_units_on_company_id"
  end

  create_table "companies", force: :cascade do |t|
    t.string "name"
    t.datetime "created_at", null: false
    t.datetime "updated_at", null: false
    t.integer "locations_count", default: 0, null: false
  end

  create_table "locations", force: :cascade do |t|
    t.string "name"
    t.bigint "business_unit_id", null: false
    t.datetime "created_at", null: false
    t.datetime "updated_at", null: false
    t.index ["business_unit_id"], name: "index_locations_on_business_unit_id"
  end

  add_foreign_key "business_units", "companies"
  add_foreign_key "locations", "business_units"
end

Meu entendimento com base nessas respostas do SO ( 1 , 2 ) é que isso deve funcionar. Não está bem documentado e é um pouco contraintuitivo como o Rails sabe automaticamente se referir à contagem de locais, mas, de fato, parece ter alguma mágica do Rails e chamar Company.reset_counters(1, :locations)corretamente define o contador para corresponder ao número de locais.

NO ENTANTO , o contador não atualiza automaticamente (para cima ou para baixo) quando locais são adicionados ou removidos, e se uma BusinessUnit com N locais for atualizada e atribuída a outra empresa, o contador só aumenta/diminui em 1 (em vez dos N locais esperados). Esse comportamento está presente no Rails 8.0.1 e 7.1.3 (que usei acidentalmente para construir meu MRE).

Há algo óbvio que estou esquecendo e que pode fazer o counter_cache funcionar corretamente?

Tenho um cenário estranho. Tenho uma lista de grupos. Para cada grupo, preciso iniciar uma tarefa para todos os conteúdos, mas preciso garantir que o último valor em cada grupo seja executado por último. Função simplificada abaixo:

public async Task DoAllTheWork(IEnumerable<IGrouping<string, string>> groups)
{
    var allTasks = new List<Task>();
    foreach (var group in groups)
    {
        var tasksInGroup = new List<Task>();
        var values = group.ToList();

        // start tasks for all except last value
        foreach (var value in values.SkipLast(1))
        {
            var theTask = SomeAsyncFunction(value);

            allTasks.Add(theTask);
            tasksInGroup.Add(theTask);
        }

        // start a task for last value once all previous tasks are done
        var lastTask = Task.Run(async () =>
        {
            await Task.WhenAll(tasksInGroup);
            SomeAsyncFunction(values.Last());
        });

        allTasks.Add(lastTask);
    }

    await Task.WhenAll(allTasks);
}

Isso funciona bem. O problema é que todas as tarefas são executadas de uma vez, o que pode acabar sendo um problema se houver muitos grupos ou se os grupos tiverem muitos valores.

Gostaria de limitar o número de tarefas simultâneas sendo executadas. A maneira mais fácil que consigo pensar é que if allTaskscontinha uma lista de tarefas que ainda não foram realmente iniciadas. Então eu poderia simplesmente fazer algo como:

Parallel.ForEach(allTasks, new ParallelOptions {MaxDegreeOfParallelism = 10},
aTask =>
{
     aTask.Start();
});

Existe alguma maneira de fazer algo assim?