All perguntas(coding)

Com o objetivo de me aprimorar e porque estava entediado, estava aprendendo as tags do Canvas em HTML seguindo a documentação do Mozilla e desenhamos um rosto lá. Tentei fazer o rosto como o Mozilla sugeriu, mas linhas apareceram no meu rosto devido aos valores e não sei por quê.

const canvas = document.querySelector(".canvas");
const ctx = canvas.getContext("2d")

ctx.beginPath()
ctx.arc(75, 75, 60, 0, Math.PI * 2, true)
ctx.moveTo(40, 40)
ctx.arc(50, 50, 10, 0, Math.PI * 2, true)
ctx.moveTo(60, 50)
ctx.arc(100, 50, 10, 0, Math.PI * 2, true)
ctx.moveTo(110, 110)
ctx.arc(80, 110, 30, 0, Math.PI, true)
ctx.stroke()

<canvas class="canvas" width="150" height="150"></canvas>

Rosto esperado:

Resultado face:

Como você pode ver, estou falando de linhas indesejadas no rosto.

Tudo o que sei e descobri é que, por algum motivo, o xvalor de moveTodeveria ser igual ao raio do círculo e os yvalores deveriam ser os mesmos — mas não sei por quê. Queria perguntar por que isso acontece.

Resumindo, não descobri o porquê, mas por algum motivo, quando brinco com os valores ou quando torno os valores incompatíveis, aparece uma linha.

Aqui está um exemplo:

struct DemoApp: View {
    @State var viewModel = DemoAppViewModel()
    var body: some View {
        VStack {
            DemoMonthView(date: viewModel.monthDate)
            DemoDayView(date: viewModel.dayDate) // FIRST
                .onTapGesture {
                    viewModel.dayDate = viewModel.dayDate.addingTimeInterval(86000)
                }
            DemoDayView(date: viewModel.monthDate) // SECOND
                .onTapGesture {
                    viewModel.monthDate = viewModel.monthDate.addingTimeInterval(1400000)
                }
        }
    }
}

@Observable
class DemoAppViewModel {
    var dayDate: Date = Date()
    var monthDate: Date = Date()
}

struct DemoMonthView: View {
    var date: Date
    @FetchRequest private var days: FetchedResults<Day> //you need to replace Day here with any Entity that will allow to reproduce the issue
    init(date: Date) {
        self.date = date
        _days = FetchRequest(
            sortDescriptors: [SortDescriptor(\.date, order: .reverse)],
            predicate: NSPredicate(value: true)
        )
        print("DemoMonthView init is called") //should be called, but without body redraws

        // heavy calculations for given month
    }
    
    var body: some View {
        if #available(iOS 17.1, *) {
            print("DemoMonthView body is called") //should not be called❓
        }
        return VStack {
            Text(date.formatted(date: .long, time: .omitted)).font(.title.bold())
        }
    }
}

struct DemoDayView: View {
    var date: Date
    
    var body: some View {
        Text(date.formatted(date: .long, time: .omitted))
    }
}

#Preview {
    DemoApp()
}

Simplificando, quando você toca FIRSTno botão, ele não deveria redesenhar a DemoMonthView, mas redesenha. Por quê? Eu realmente preciso evitar isso tocando FIRSTno botão toda vez. SECONDO botão redesenha DemoMonthViewa visualização corretamente, pelo que entendi. Mas por que o PRIMEIRO?

Quando comento dayse _daysassocio no init, então está tudo bem, ele NÃO redesenha...

Mas essa situação é apenas uma versão resumida do meu aplicativo real, mais complexo. Há uma fetchRequest com cálculos complexos que não deveria ser chamada com tanta frequência, como tocar no botão, como aqui no exemplo, quando tocar nesse botão não altera nada relacionado à DemoMonthView.

Se o motivo for a falta de conhecimento, o que devo saber para evitar isso?

Por que isso importa aqui? Porque preciso atualizar isso DemoMonthViewSOMENTE quando monthDatehouver alterações, não sempre que houver dayDatealterações.

No código Rust a seguir, um Boxou Rccontendo um u32tem 8 bytes, enquanto um Boxou Rccontendo uma fatia tem 16 bytes. Eu entendo o porquê; um ponteiro inteligente apontando para uma área de memória de tamanho dinâmico (como uma fatia) incluirá o comprimento dessa área de memória, além do endereço.

fn main()
{
    println!("Size of Box<u32>: {} bytes", std::mem::size_of::<Box<u32>>()); // 8
    println!("Size of Box<[u32]>: {} bytes", std::mem::size_of::<Box<[u32]>>()); // 16
    println!("Size of Box<str>: {} bytes", std::mem::size_of::<Box<str>>()); // 16

    println!("Size of Rc<u32>: {} bytes", std::mem::size_of::<Rc<u32>>()); // 8 
    println!("Size of Rc<[u32]>: {} bytes", std::mem::size_of::<Rc<[u32]>>()); // 16
    println!("Size of Rc<str>: {} bytes", std::mem::size_of::<Rc<str>>()); // 16
}

Minha pergunta é como o compilador do Rust sabe qual deve ser o tamanho do ponteiro e como esse comprimento adicional é realmente usado ou interpretado.

Para começar, aqui está meu melhor palpite sobre o que está acontecendo com o tamanho do ponteiro. Ambos Rce Boxtêm as seguintes estruturas:

pub struct Box<T: ?Sized, A: Allocator = Global>(Unique<T>, A);

pub struct Rc<T: ?Sized, A: Allocator = Global> {
    ptr: NonNull<RcInner<T>>,
    phantom: PhantomData<RcInner<T>>,
    alloc: A,
}

Presumo que, de alguma forma, o Allocatortipo esteja dando ao Box/ Rc8 bytes extras de espaço para o comprimento, mas não sei como isso está realmente acontecendo. Analisei o código do alocador, mas não entendi o que a inclusão do alocador aqui realmente faz. Se eu fosse criar meu próprio tipo de ponteiro/contêiner, incluir o Allocatortipo na minha struct seria suficiente para ter esse comportamento?

Quanto ao modo como o comprimento é usado, meu entendimento é que tanto Box<T>e Rc<T>podem ser coagidos de forma transparente para &T, e &Té um tipo primitivo que o compilador mais ou menos espera que seja um ponteiro para uma única unidade de dados, ou um ponteiro e um comprimento para uma matriz de dados, mas nesse caso, a Derefimplementação me confunde.

impl<T: ?Sized, A: Allocator> Deref for Rc<T, A> {

    type Target = T;

    #[inline(always)]
    fn deref(&self) -> &T {
        &self.inner().value
    }
}

Sinto que esperaria que isso, de alguma forma, "perdesse" a informação sobre o comprimento, já que essa informação está incluída com o Rce não com o RcInnerou com o valor T. Mas, em vez disso, o compilador magicamente sabe disso, porque Rc<[T]>é um ponteiro, assim como &[T], ele sabe que Rctambém tem esse comprimento um tanto oculto após o endereço, embora Rcnunca o inclua explicitamente. Eu sei que o comprimento não é armazenado com , [T]como você poderia esperar, ele é armazenado na pilha com o endereço de [T], seja por meio de um Box, um Rc, ou uma referência simples.

Então essas são minhas duas perguntas: como os dados adicionais para um ponteiro gordo são definidos/estabelecidos na própria estrutura de dados e como o Rust sabe que um tipo como Rcou Boxdeve ser não apenas um ponteiro, mas um ponteiro gordo com informações adicionais sobre o comprimento?

Aqui estão algumas perguntas semelhantes que me ajudaram a entender como fatias/ponteiros/ponteiros grossos funcionam como pano de fundo para isso:

• Qual é a diferença entre uma fatia e uma referência em Rust?
• O que é um "ponteiro gordo"?
• Qual é a diferença entre uma fatia e uma matriz?

Quero executar repetidamente a seguinte classe de teste:

class Test {

    static Foo foo;

    @BeforeAll
    static void setUpAll() {
        foo = generateRandomFoo();
    }

    @ParameterizedTest
    @ValueSource(ints = {1, 2, 3, 4})
    void testBar(int i) {
        assertThat(foo.bar(i))
                .hasSize(i);
    }

    @ParameterizedTest
    @ValueSource(ints = {1, 2, 3, 4})
    void testQux(int i) {
        assertThat(foo.qux(i))
                .contains(i);
    }
}

Tentei usar a anotação @ParameterizedTestno método junto com @RepeatedTest, mas eles não podem ser usados ​​juntos. Mesmo que pudessem, ainda não faria o que eu preciso, porque preciso que a inicialização de fooin setUpAllaconteça entre repetições, e as invocações parametrizadas devem acontecer dentro de uma repetição (com o mesmo valor de foo).

Aqui está o que eu preciso:

• repetição 1:
  • inicialização de fooemsetUpAll
  • execução de testBarcom argumentos 1..4
  • execução de testQuxcom argumentos 1..4
• repetição 2:
  • inicialização de fooemsetUpAll
  • execução de testBarcom argumentos 1..4
  • execução de testQuxcom argumentos 1..4
• etc.

Existe alguma maneira de fazer isso no JUnit 5 (Júpiter)?

Como posso alinhar à direita cada um DataCellna Flutter DataTable ?

Por exemplo, neste caso, como posso ter todos os números alinhados à direita?

Widget build(BuildContext context) {
  return DataTable(
    columns: const <DataColumn>[
      DataColumn(
        label: Expanded(child: Text('Name', style: TextStyle(fontStyle: FontStyle.italic))),
      ),
      DataColumn(
        label: Expanded(child: Text('Number', style: TextStyle(fontStyle: FontStyle.italic))),
      ),
    ],
    rows: const <DataRow>[
      DataRow(
        cells: <DataCell>[
          DataCell(Text('Sarah')),
          DataCell(Text('1')),
        ],
      ),
      DataRow(
        cells: <DataCell>[
          DataCell(Text('Janine')),
          DataCell(Text('100')),
        ],
      ),
      DataRow(
        cells: <DataCell>[
          DataCell(Text('William')),
          DataCell(Text('1000')),
        ],
      ),
    ],
  );
}

Desde já, obrigado!

Eu estava tentando executar o comando abaixo dentro da versão 3.0 do Airflow, mas recebi o erro "comando não encontrado"

airflow users create \
    --username "airflow" \
    --firstname "airflow"
    -- rest all params here

Como podemos criar usuários usando o gerenciador de autenticação do Fab? Dê alguns exemplos.

Quero que meu mapa leafmap ocupe TODO o plano de fundo ou o plano principal, sem nenhuma margem ou algo que o mova para cima, para baixo, para a esquerda ou para a direita. No entanto, ainda tenho margens nas partes superior e inferior. Além disso, se eu aumentar a altura, isso cria um deslocamento em Y , e eu também não quero isso, mas uma janela estática ajustada ao espaço principal ou de fundo. Anexei uma captura de tela do que quero dizer. Por outro lado, preciso adicionar camadas de um netcdf, então é melhor usar o folium ou o leafmap? Por favor, me ajudem. Agradeço antecipadamente.

import streamlit as st
import leafmap.foliumap as leafmap 

st.set_page_config(
    page_title=None,
    page_icon=None,
    layout="wide",
    initial_sidebar_state="auto",
)
st.markdown(
    """
    <style>
        header {visibility: hidden;}
        footer {visibility: hidden;}
        .block-container {
            padding: 0 !important;
            margin: 0 !important;
            max-width: 100% !important;
            width: 100% !important;
        }
        .main {
            padding: 0 !important;
            margin: 0 !important;
        }
        .css-1aumxhk {
            margin-top: 0 !important;
        }
    </style>
    """,
    unsafe_allow_html=True,
)

m = leafmap.Map(center=[-0.1807, -78.4678], zoom=7)
m.to_streamlit(height=830)

Margens

Como posso aplicar a mesma função abaixo às outras duas seções da div? Gostaria que os botões primários uke intem cada div mostrassem/ocultassem o conteúdo dentro de suas seções filhas. Outro problema é que estou usando abas. Cada div está hospedada em uma aba diferente, então a classe ativa clicada precisa permanecer na alternância de abas.

$('.uk').on("click", function() {
  $('#div-ONE-INT').hide();
  $('#div-ONE-UK').show();
  $(this).addClass('active');
  $('.int').removeClass('active');
  return false;
});

$('.int').on("click", function() {
  $('#div-ONE-INT').show();
  $('#div-ONE-UK').hide();
  $(this).addClass('active');
  $('.uk').removeClass('active');
  return false;
});

$('#div-ONE-INT').hide();

<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.7.1/jquery.min.js"></script>
<div class="ONE">
  <a href="#" class="primary-btn active uk">UK</a>
  <a href="#" class="primary-btn int">International</a>

  <section id="div-ONE-UK">
    <!-- UK ONE content -->
  </section>

  <section id="div-ONE-INT">
    <!-- Int ONE content -->
  </section>
</div>

<div class="TWO">
  <a href="#" class="primary-btn uk active">UK</a>
  <a href="#" class="primary-btn int">International</a>

  <section id="div-TWO-UK">
    <!-- UK TWO content -->
  </section>

  <section id="div-TWO-INT">
    <!-- Int TWO content -->
  </section>
</div>

<div class="THREE">
  <a href="#" class="primary-btn uk active">UK</a>
  <a href="#" class="primary-btn int">International</a>

  <section id="div-THREE-UK">
    <!-- UK THREE content -->
  </section>

  <section id="div-THREE-INT">
    <!-- Int THREE content -->
  </section>
</div>

Tenho uma classe na qual quero que alguns slots sejam nulos quando o objeto for criado, mas eles devem ser configuráveis ​​apenas com objetos de um determinado tipo. Algo como:

(defclass Something ()
  ((foo :initarg :foo
        :type (or character 'nil)
        :initform nil
        :accessor something-foo)))

Se eu disser apenas :type character, ou :type (or character nil), então o SBCL reclama por NILnão ser do tipo de caractere declarado. Se eu disser :type (or character 'nil), então parece que ele aceita caracteres e o tipo de símbolo, já que qualquer símbolo parece ser:

CL-USER> (defvar *foo* (make-instance 'Something))
*FOO*
CL-USER> (setf (something-foo *foo*) 'test)
TEST
CL-USER> (something-foo *foo*)
TEST

Existe uma maneira de afirmar que um slot é nulo ou possui o tipo fornecido? Ou devo simplesmente omitir o especificador de tipo e afirmar o tipo no método acessador ou escritor?

Editar:

Depois de pensar um pouco, talvez a expressão seja: :type characterdeixe-o desvinculado e verifique se o slot está vinculado ou não, em vez de verificar se é nulo ou não nulo?

Estou usando o Shortcode no Wordpress e também usando o Ninja Tables. O código está sendo extraído de uma Planilha Google gerenciada por um administrador não desenvolvedor. Geralmente é fácil. Estou procurando incorporar isso em um modelo em vez de instalar o shortcode manualmente em todas as postagens.

A seguir está o trecho do shortcode que estou usando:

[ninja_tables id="446" search=0 filter="1100" filter_column="Filter4" colunas="nome,endereço,cidade,site,facebook"]

Estou procurando uma maneira de o shortcode usar uma variável no lugar do valor do filtro "1100" para que ele preencha automaticamente com o ID da postagem atual. Isso elimina a necessidade de digitar manualmente o shortcode na postagem. Eu adicionaria manualmente o ID da postagem na planilha, o que é muito mais fácil de manter.

Encontrei referências à programação em PHP, mas não sou desenvolvedor PHP e não estou tentando me aprofundar em soluções de desenvolvimento. Espero uma solução mais simples com possíveis variáveis ​​que possam ler os detalhes da página no shortcode.