All perguntas(coding)

Tenho várias classes diferentes com campos e propriedades diferentes. No entanto, um campo comum a todas as classes é um private Boolean isShown, que representa se uma classe deve ser exibida ou não. De todas as classes que possuem isShown, apenas uma delas pode precisar isShownser exibida trueem um determinado momento. Também é possível que nenhuma das classes tenha isShowndefinido como true. No meu programa principal, tenho um objeto de cada classe. Quero ter um método que possa encontrar o objeto que foi isShowndefinido como true(se houver) e retorná-lo, mas não sei como fazer isso.

Estou aprendendo POO em Fortran. E me pergunto sobre o interesse de sobrecarregar procedimentos com limite de tipo quando o tipo de um argumento não é conhecido em tempo de compilação.

Deixe-me explicar, passo a passo, meu problema (Esses programas são apenas exemplos para aumentar minha habilidade em fortran)

Primeiro programa: sobrecarga de um procedimento de tipo limitado

module my_mod

  implicit none
  
  type :: my_type_t
    character(len=128) :: my_text
  contains
    procedure :: integer_print, real_print
    generic :: my_print => integer_print, real_print
  end type my_type_t
  
  contains
  
  subroutine integer_print(this, my_int)
    class(my_type_t), intent(in) :: this
    integer, intent(in) :: my_int
    write (*,"(a,a,i0)") trim(this%my_text),' integer ', my_int
  end subroutine integer_print
  
  subroutine real_print(this, my_real)
    class(my_type_t), intent(in) :: this
    real, intent(in) :: my_real
    write (*,"(a,a,f0.3)") trim(this%my_text),' real ', my_real
  end subroutine real_print

end module my_mod

program my_pgm

  use my_mod
  implicit none
  
  type(my_type_t) :: my_var
  my_var%my_text = "Hello"
  
  call my_var%my_print(10)
  call my_var%my_print(9.9)

end program my_pgm

Deu o resultado esperado. Ou integer_printou real_printé usado, dependendo do tipo de my_printargumento (inteiro ou real).

Segundo programa (ou passo, eu diria): um tipo abstrato é usado e há dois tipos derivados: my_int_te my_real_t. É muito semelhante ao primeiro exemplo. Mas, dois tipos são usados, um para inteiros e outro para reais.

module my_mod

  implicit none
  
  type, abstract :: my_abstract_t
  end type  my_abstract_t
  
  type, extends(my_abstract_t) :: my_int_t
    integer :: an_integer
  end type my_int_t
  
  type, extends(my_abstract_t) :: my_real_t
    real :: a_real
  end type my_real_t
  
  type :: my_type_t
    character(len=128) :: my_text
  contains
    procedure :: integer_print, real_print
    generic :: my_print => integer_print, real_print
  end type my_type_t
  
  contains
  
  subroutine integer_print(this, my_int)
    class(my_type_t), intent(in) :: this
    type(my_int_t), intent(in) :: my_int
    write (*,"(a,a,i0)") trim(this%my_text),' integer ', my_int%an_integer
  end subroutine integer_print
  
  subroutine real_print(this, my_real)
    class(my_type_t), intent(in) :: this
    type(my_real_t), intent(in) :: my_real
    write (*,"(a,a,f0.3)") trim(this%my_text),' real ', my_real%a_real
  end subroutine real_print

end module my_mod

program my_pgm

  use my_mod
  implicit none
  
  type(my_type_t) :: my_var
  type(my_int_t) :: my_int
  type(my_real_t) :: my_real
  
  my_var%my_text = "Hello"
  
  my_int%an_integer = 10
  my_real%a_real = 9.9
  
  call my_var%my_print(my_int)
  call my_var%my_print(my_real)

end program my_pgm

O tipo de my_intand my_realé conhecido no momento da compilação, portanto a saída está correta. E a mesma chamada my_var%my_print(...)é usada independentemente do tipo da variável ( my_int_tor my_real_t), como no primeiro exemplo.

Mas agora esse é o meu problema.

program my_pgm

  use my_mod
  implicit none
  
  type(my_type_t) :: my_var
  class(my_abstract_t), allocatable :: my_number
  
  allocate(my_int_t::my_number)
  ! or allocate(my_real_t::my_number)
  
  my_var%my_text = "Hello"

  select type (my_number)
  type is (my_int_t)
      my_number%an_integer = 10
  type is (my_real_t)
      my_number%a_real = 9.9
  end select
  
  select type (my_number)
  type is (my_int_t)
      call my_var%my_print(my_number)
  type is (my_real_t)
      call my_var%my_print(my_number)
  end select

end program my_pgm

O tipo de my_numbernão é conhecido em tempo de compilação. Então, preciso usar um trecho de código que achei bastante redundante:

  select type (my_number)
  type is (my_int_t)
      call my_var%my_print(my_number)
  type is (my_real_t)
      call my_var%my_print(my_number)
  end select

Eu teria preferido escrever apenas uma linha: call my_var%my_print(...)como no primeiro e no segundo exemplos. Devo concluir que a sobrecarga de procedimento não tem interesse no terceiro exemplo e é melhor usar integer_printe real_printdiretamente no select typebloco? Ou há algo que eu não entendi?

Edição 1

Seguindo os comentários de Francescalus, se entendi bem, não consegui evitar o select typebloqueio. Então, modifiquei o programa da seguinte maneira.

module my_mod

  implicit none
  
  type, abstract :: my_abstract_t
  end type  my_abstract_t
  
  type, extends(my_abstract_t) :: my_int_t
    integer :: an_integer
  end type my_int_t
  
  type, extends(my_abstract_t) :: my_real_t
    real :: a_real
  end type my_real_t
  
  type :: my_type_t
    character(len=128) :: my_text
  contains
    procedure, private :: real_print, integer_print
    procedure, public :: my_print
  end type my_type_t
  
  contains
  
  subroutine integer_print(this, my_int)
    class(my_type_t), intent(in) :: this
    type(my_int_t), intent(in) :: my_int
    write (*,"(a,a,i0)") trim(this%my_text),' integer ', my_int%an_integer
  end subroutine integer_print
  
  subroutine real_print(this, my_real)
    class(my_type_t), intent(in) :: this
    type(my_real_t), intent(in) :: my_real
    write (*,"(a,a,f0.3)") trim(this%my_text),' real ', my_real%a_real
  end subroutine real_print
  
  subroutine my_print(this,my_number)
    class(my_type_t), intent(in) :: this
    class(my_abstract_t), intent(in) :: my_number
    
    select type (my_number)
    type is (my_int_t)
        call this%integer_print(my_number)
    type is (my_real_t)
        call this%real_print(my_number)
    end select
    
  end subroutine my_print
    

end module my_mod

program my_pgm

  use my_mod
  implicit none
  
  type(my_type_t) :: my_var
  class(my_abstract_t), allocatable :: my_number1, my_number2
  
  my_number1 = my_int_t(an_integer = 10)
  my_number2 = my_real_t(a_real = 9.9)
  
  my_var%my_text = "Hello"

  call my_var%my_print(my_number1)
  call my_var%my_print(my_number2)
  
end program my_pgm

Qualquer comentário será apreciado.

Tentei corresponder a um genérico Result<&mut T, T>dentro de um const fn, mas o compilador não permitiu. Seria necessário remover o valor no final do escopo, o que atualmente não é possível dentro de um const fn.

Trunquei um pouco meu código e finalmente cheguei a este trecho. Ele continua dando o mesmo erro, pelo mesmo motivo, mas não é mais genérico.

struct Dummy;

impl Drop for Dummy {
    fn drop(&mut self) {
        println!("dropped");
    }
}

const fn const_match(result: Result<Dummy, ()>) -> Result<Dummy, ()> {
    match result { //^^^^^^ the destructor for this type cannot be evaluated in constant functions
        Ok(ok) => Ok(ok),
        Err(err) => Err(err),
    }
} // <- value is dropped here

O compilador me dá a seguinte mensagem de erro:

error[E0493]: destructor of `Result<Dummy, ()>` cannot be evaluated at compile-time
  --> <source>:9:22
   |
9  | const fn const_match(result: Result<Dummy, ()>) -> Result<Dummy, ()> {
   |                      ^^^^^^ the destructor for this type cannot be evaluated in constant functions
...
14 | }
   | - value is dropped here

Ao remover consttudo, a compilação fica perfeita, então criei um teste para verificar se o valor realmente é descartado dentro dessa função.

struct Dummy;

impl Drop for Dummy {
    fn drop(&mut self) {
        println!("dropped");
    }
}

fn const_match(result: Result<Dummy, ()>) -> Result<Dummy, ()> {
    match result {
        Ok(ok) => Ok(ok),
        Err(err) => Err(err),
    }
}

fn main() {
    let dummy = const_match(Ok(Dummy));
    let err = const_match(Err(()));

    std::mem::forget(dummy);
}

Aqui está o link do godbolt para um exemplo de código idêntico. Como esperado, ele não produz nenhuma saída, então o destruidor nunca é executado dentro de const_match.

Por que o destruidor precisa ser capaz de ser executado?

Nossa tabela armazena os números das linhas de um pedido. É possível concatená-los em uma string, onde a primeira e a última linhas sequenciais são separadas por um hífen e as linhas não sequenciais são separadas por uma vírgula? Alguns de nossos pedidos podem ter mais de 100 linhas do mesmo item e, em vez de listar cada linha separadamente, gostaríamos de condensá-las em "Linhas: 1-100" ou "Linhas: 1-20, 25, 30-50, 75-100", etc.

Fonte

Consulta atual

Usando STRING_AGG, consegui agrupá-los por linhas individuais, mas não consigo descobrir como identificar as partes sequenciais e extrair seus primeiros/últimos valores para o hífen. LAG e LEAD podem ser usados ​​em conjunto com STRING_AGG?

SELECT
    CONCAT('Lines: ', STRING_AGG(Line, ', ') WITHIN GROUP (ORDER BY Line)) AS [Line],
    Item
FROM Table
GROUP BY Item

Resultado atual

Resultado desejado

Problema e Contexto:

Estou tentando configurar o Apache Ignite (3.0.0) como uma grade de dados na memória. A ideia é usá-lo como um cache e carregar dados de um RDBMS externo, como o Postgres. Tenho um caso de uso específico em que tenho alguns arquivos de dados com tipo XML e tipo TXT no Postgres. Quero poder carregar os dados no Apache Ignite (configurando-o como um cache) e usá-los em meus aplicativos Java e CPP.

O problema que estou enfrentando é que não há instruções claras nem material útil on-line para esta versão específica do Apache Ignite para configurar isso.

O que eu fiz até agora:

Baixei os binários do Apache Ignite 3 na minha máquina (subsistema Linux). Consegui configurá-lo com sucesso e iniciar um cluster com um nó. Consegui criar uma tabela com dados de exemplo usando a interface do usuário do gridGain e também por meio da API do IgniteTables.

Até agora, li a documentação oficial em: https://ignite.apache.org/docs/ignite3/latest/index

Também analisei os exemplos no repositório github: https://github.com/apache/ignite-3/tree/main/examples

Encontrei muitas informações sobre como fazer isso na versão 2.x do Apache Ignite, onde a configuração é feita por meio de configurações XML/Java (referência específica: https://ignite.apache.org/docs/latest/persistence/external-storage#rdbms-integration ).
Também tentei, mas o pacote/classes CacheConfiguration não parecem estar disponíveis na versão mais recente (3.0.0).
Outra atualização da GridGain é que eles migraram para configurações no estilo HOCON, então a configuração de cache via XML não parece mais aplicável.

• Configuração baseada em HOCON : Human-Optimized Config Object Notation (HOCON) é agora a linguagem de configuração padrão, oferecendo uma alternativa mais legível e flexível ao XML.

Também verifiquei cursos/vídeos na Universidade Gridgain e no canal oficial do Youtube.

Quero fazer uma projeção no atributo de objeto de uma entidade com o Hibernate Criteria 6.

Aqui estão meus modelos:

    @Entity
    public class MyAuthor {
        private String id;
        private String name;
        private int nbBooks;
        private Date birthDate;
        @Embedded
        private MyAddress address;
    }

    @Embeddable
    public class MyAddress {
        private String street;
        private MyCity city;
    }

    @Entity
    public class MyCity {
       String id;
       String name;
    }

Aqui está meu teste de unidade:

    // We populate data with CITY_1 & CITY_2, ADDR_1 on CITY_1, ADDR_2 on CITY_1 and ADDR_3 on CITY_2 with @Before

    CriteriaBuilder criteriaBuilder = sessionFactory.getCurrentSession().getCriteriaBuilder();
    CriteriaQuery<MyCity> query = criteriaBuilder.createQuery(MyCity.class);
    Root<MyAuthor> root = query.from(MyAuthor.class);
    Join<MyAuthor, MyAddress> from = root.join("address", JoinType.LEFT);
    
    // produce this request : select c1_0.id,c1_0.name from MyAuthor ma1_0 left join MyCity c1_0 on c1_0.id=ma1_0.city_id where c1_0.name is not null
    query.select(from.get("city"))
        .where(criteriaBuilder.isNotNull(from.get("city").get("name")));
        
    // produce the same request : select c1_0.id,c1_0.name from MyAuthor ma1_0 left join MyCity c1_0 on c1_0.id=ma1_0.city_id where c1_0.name is not null
    // query.multiselect(from.get("city").get("id"), from.get("city").get("name"))
    // .where(criteriaBuilder.isNotNull(from.get("city").get("name")));


    // with the query.select(), there are 2 results, with the multiselect there are 3.
    List<MyCity> cities = sessionFactory.getCurrentSession().createQuery(query).getResultList();
    
    assertEquals(3, cities.size());

Não entendo como o SQL gerado é o mesmo MAS o comprimento do resultado é diferente.

Alguma ideia? Muito obrigado.

Desejo acessar as tabelas do seguinte site:

https://www.marketbeat.com/ratings/

No entanto, as páginas só podem ser alteradas definindo a "Data do Relatório".

Eu sei que posso alterar a data via automação do navegador... mas é muito lento e fiquei curioso para saber se existe uma maneira mais rápida. Tentei acessar o endpoint XHR, mas o payload para a data não está funcionando.

Ao inspecionar a aba Rede, vejo que há uma solicitação de postagem XHR. No entanto, se eu tentar solicitar o endpoint com um payload que define a data, recebo apenas dados do dia atual, como se eu não tivesse definido uma data. Acho que o payload não está funcionando corretamente.

from bs4 import BeautifulSoup
import pandas as pd
import requests

payload = {
  "ctl00$cphPrimaryContent$txtStartDate": "09/17/2024",
}
r = requests.post('https://www.marketbeat.com/ratings/', json=payload)
soup = BeautifulSoup(r.text, 'html.parser')
tables = pd.read_html(str(soup))

Posso estar enganado e esse ponto final é de alguma forma oculto ou somente para uso interno?

Além disso, se eu usar o Selenium para alterar a "Data do Relatório", depois de usar .clear() no input_element, a página será recarregada, outro element_id será atribuído ao campo de entrada e o valor não será apagado, mas redefinido para seu valor inicial.

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys


driver = webdriver.Chrome()
driver.get('https://www.marketbeat.com/ratings/')

input_element = driver.find_element(By.ID, "cphPrimaryContent_txtStartDate")#.sendKeys("value", "1/1/2023");

if(input_element.is_displayed()):
    input_element.clear()
    input_element.send_keys("1/1/2023")

Então isso também não funciona. Qualquer sugestão seria super útil. Obrigado.

Quando desserializo um número JSON para um BigDecimalusando readTree, os resultados não preservam a escala, ou seja, são tratados 0.10como 0.1. Por outro lado, se eu desserializo usando readValue, ele preserva a escala, retornando um BigDecimalcom a escala correta de 2:

    ObjectMapper objectMapper = new ObjectMapper();
    objectMapper.enable(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS);
    JsonNode jsonNode = objectMapper.readTree("0.10");
    BigDecimal numberFromReadTree = ((DecimalNode)jsonNode).decimalValue();
    BigDecimal numberFromReadValue = objectMapper.readValue("0.10", BigDecimal.class);

    System.out.println(numberFromReadTree); // Prints 0.1, i.e. scale = 1
    System.out.println(numberFromReadValue); // Prints 0.10, i.e. scale = 2

Existe algum motivo para essa aparente inconsistência e existe uma opção que eu possa definir para manter a escala igual à entrada (ou seja, para ser consistente com readValue)?

Recebi muitos avisos do compilador para a biblioteca eigen, um exemplo sendo:

Warning C4819   The file contains a character that cannot be represented in the current code page (950). Save the file in Unicode format to prevent data loss

Algumas sugestões foram salvar novamente os arquivos em Unicode, mas isso não significa que eu "alterei" o código-fonte da biblioteca e ele reaparecerá após minha próxima atualização da biblioteca?

Por exemplo, tenho algum texto

aaa foo
bbb foo
ccc foo?
ddd foo
eee foo?
...

Quero pesquisar todos os foos sem um ?, como nas linhas 1, 2 e 4 do texto acima. Como posso fazer isso?