All perguntas(coding)

Estou muito confuso sobre como funcionam os backups de banco de dados SQL do Azure (PITR e LTR). Observei algumas coisas no backup, como as seguintes:

1. PITR - Retenção de ponto mais antigo no tempo ocorrendo todos os dias. Por exemplo:
2. PITR configurado para 7 dias

exemplo 1:

2025-4-28 - current Day,
2025-4-27,
2025-4-26,
2025-4-25,
2025-4-24,
2025-4-23,
2025-4-22,
2025-4-21 - Earliest PITR restore point

exemplo 2:

2025-4-29 - current Day,
2025-4-28,
2025-4-27,
2025-4-26,
2025-4-25,
2025-4-24,
2025-4-23,
2025-4-22 - Earliest PITR restore point

então, podemos restaurar também 20/04/2025? ou só podemos restaurar de (primeiro ponto de restauração PITR) 21/04/2025 até o dia atual (28/04/2025)?

Por favor, alguém pode me explicar como isso realmente funciona.

E o LTR?

Meu código Python armazena milhões de IDs em várias estruturas de dados para implementar um algoritmo clássico. O tempo de execução é bom, mas o uso de memória é péssimo.

Esses IDs são ints. Presumo que, como os ints do Python começam com 28 bytes e crescem, o preço é alto. Como são apenas IDs opacos, e não objetos matemáticos propriamente ditos, eu conseguiria me virar com apenas 4 bytes para eles.

Existe uma maneira de armazenar IDs em Python sem usar os 28 bytes completos? Por exemplo, preciso colocá-los como chaves e valores em dicionários?

Observação: A solução comum de usar algo como BumPy não funcionará aqui, porque não é um array contíguo. São chaves e valores em um dicionário, dicionários de dicionários, etc.

Também estou aberto a outros interpretadores Python que consomem menos memória para ints.

Esta não é uma solução para o meu problema. A resposta sugerida substitui os valores por Nones. Eu literalmente preciso que o tamanho do meu vetor seja reduzido.

MRE:

use tokio::sync::mpsc;

#[tokio::main]
async fn main() {

    // Pits the singers against each other...
    // Please do not get confused by the type of the sender used in here.
    // This still will showcase the same problem.
    fn pit(singers: &mut Vec<(String, mpsc::Sender<String>)>) {
        use rand::Rng;
        let mut rng = rand::thread_rng();
        let i1 = rng.gen_range(0..singers.len());
        let i2 = rng.gen_range(0..singers.len());
        // This will add dunsel "singers" to the vector who will get
        // pitted against one another. The actual code makes sure that
        // there are at least 2 singers in queue. What is does not do - 
        // and neither should it - is check if they are dummy objects.
        // Rust did not like me using singers[i1].take().unwrap() and
        // complained about iterators not being implemented for Sender?
        let (dunsel, _) = mpsc::channel::<String>(1);
        let s1 = std::mem::replace(&mut singers[i1], (String::new(), dunsel.clone()));
        let s2 = std::mem::replace(&mut singers[i2], (String::new(), dunsel.clone()));
        // returns s1, s2... not needed for MRE
    }

    let mut v = vec![];
    let (tx, _) = mpsc::channel::<String>(256); // receiver is not needed for MRE
    for name in vec!["name1".to_string(), "name2".to_string(), "name3".to_string()] {
        // In the actual code, the singer clients are sent this tx
        // and they send their transmitter channels via this tx, which
        // is then pushed to the vector. Here, it just accepts `String`s
        // So, tx is of the type mpsc::Sender<mpsc::Sender<String>>!!
        v.push((name.clone(), tx.clone()));
    }
    tokio::spawn(async move {
        let mut v = v;
        pit(&mut v); 
    });
}

Captura de tela do meu problema

Estou com um problema em que a borda da visualização principal de uma classe UIview personalizada está sobrepondo a rankbadgeview dentro dessa classe personalizada. Não consigo entender o porquê. Tentei trazer a subvisualização rankbadgeview para a frente, junto com o uilabel dentro dela, mas ainda não funciona. Alguém pode me ajudar a identificar o problema?

class LeaderboardCircleView: UIView {
    private let mainLabel = UILabel()
    let rankBadgeView = UIView()
    private let rankLabel = UILabel()
    private let scoreLabel = UILabel()
    
    init(mainText: String, rankText: String, backgroundColor: UIColor, score: Int) {
        super.init(frame: .zero)
        setupViews()
        configure(mainText: mainText, rankText: rankText, backgroundColor: backgroundColor, score: score)
    }
    
    required init?(coder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }


    private func updateScoreLabelWith(score: Int) {
        let trophyAttachment = NSTextAttachment()
        trophyAttachment.image = UIImage(systemName: "trophy.fill")?.withTintColor(.systemYellow, renderingMode: .alwaysOriginal)
        trophyAttachment.bounds = CGRect(x: 0, y: -2, width: 16, height: 16)
        
        let trophyString = NSAttributedString(attachment: trophyAttachment)
        let scoreString = NSAttributedString(string: " \(score) pts", attributes: [
            .font: AppStyle.shared.headerFont(size: 12),
            .foregroundColor: UIColor.darkGray
        ])
        
        let fullScoreText = NSMutableAttributedString()
        fullScoreText.append(trophyString)
        fullScoreText.append(scoreString)
        
        scoreLabel.attributedText = fullScoreText
    }

    
    private func setupViews() {
        layer.borderWidth = 2
        layer.borderColor = AppStyle.shared.primaryColor?.cgColor
        translatesAutoresizingMaskIntoConstraints = false
        clipsToBounds = false
        
        mainLabel.translatesAutoresizingMaskIntoConstraints = false
        mainLabel.textAlignment = .center
        mainLabel.adjustsFontSizeToFitWidth = true
        mainLabel.minimumScaleFactor = 0.5
        mainLabel.numberOfLines = 2
        mainLabel.font = AppStyle.shared.headerFont(size: 18)
        mainLabel.textColor = .white
        addSubview(mainLabel)
        
        rankBadgeView.translatesAutoresizingMaskIntoConstraints = false
        rankBadgeView.clipsToBounds = true
        rankBadgeView.backgroundColor = AppStyle.shared.primaryColor
        rankBadgeView.layer.zPosition = 1  // Sends it behind the border

        addSubview(rankBadgeView)
        
        rankLabel.translatesAutoresizingMaskIntoConstraints = false
        rankLabel.textAlignment = .center
        rankLabel.font = AppStyle.shared.headerFont(size: 12)
        rankLabel.textColor = .white
        rankBadgeView.addSubview(rankLabel)
        
        scoreLabel.translatesAutoresizingMaskIntoConstraints = false
        scoreLabel.textAlignment = .center
        scoreLabel.adjustsFontSizeToFitWidth = true
        scoreLabel.minimumScaleFactor = 0.5
        scoreLabel.numberOfLines = 1
        addSubview(scoreLabel)
        
        NSLayoutConstraint.activate([
            mainLabel.leadingAnchor.constraint(equalTo: leadingAnchor, constant: 10),
            mainLabel.trailingAnchor.constraint(equalTo: trailingAnchor, constant: -10),
            mainLabel.centerXAnchor.constraint(equalTo: centerXAnchor),
            mainLabel.centerYAnchor.constraint(equalTo: centerYAnchor),
            
            rankBadgeView.centerXAnchor.constraint(equalTo: centerXAnchor),
            rankBadgeView.bottomAnchor.constraint(equalTo: bottomAnchor, constant: 12),
            rankBadgeView.widthAnchor.constraint(equalToConstant: 30),
            rankBadgeView.heightAnchor.constraint(equalToConstant: 30),
            
            rankLabel.centerXAnchor.constraint(equalTo: rankBadgeView.centerXAnchor),
            rankLabel.centerYAnchor.constraint(equalTo: rankBadgeView.centerYAnchor),
            
            scoreLabel.topAnchor.constraint(equalTo: rankBadgeView.bottomAnchor, constant: 4),
            scoreLabel.centerXAnchor.constraint(equalTo: centerXAnchor)
        ])
        
        bringSubviewToFront(rankBadgeView)
        rankBadgeView.bringSubviewToFront(scoreLabel)
    }
    
    private func configure(mainText: String, rankText: String, backgroundColor: UIColor, score: Int) {
        mainLabel.text = mainText
        self.backgroundColor = backgroundColor
        rankLabel.text = rankText
        
        let trophyAttachment = NSTextAttachment()
        trophyAttachment.image = UIImage(systemName: "trophy.fill")?.withTintColor(.systemYellow, renderingMode: .alwaysOriginal)
        trophyAttachment.bounds = CGRect(x: 0, y: -2, width: 16, height: 16)
        
        let trophyString = NSAttributedString(attachment: trophyAttachment)
        let scoreString = NSAttributedString(string: " \(score) pts", attributes: [
            .font: AppStyle.shared.headerFont(size: 12),
            .foregroundColor: UIColor.darkGray
        ])
        
        let fullScoreText = NSMutableAttributedString()
        fullScoreText.append(trophyString)
        fullScoreText.append(scoreString)
        
        scoreLabel.attributedText = fullScoreText
    }
    
    override func layoutSubviews() {
        super.layoutSubviews()
        
        layer.cornerRadius = bounds.width / 2
        rankBadgeView.layer.cornerRadius = rankBadgeView.bounds.width / 2
        
        layer.shadowColor = UIColor.black.cgColor
        layer.shadowOpacity = 0.2
        layer.shadowRadius = 6.0
        layer.shadowOffset = CGSize(width: 0, height: 4)
        layer.masksToBounds = false
        
        rankBadgeView.layer.shadowColor = UIColor.black.cgColor
        rankBadgeView.layer.shadowOpacity = 0.2
        rankBadgeView.layer.shadowRadius = 4.0
        rankBadgeView.layer.shadowOffset = CGSize(width: 0, height: 2)
        rankBadgeView.layer.masksToBounds = false
    }
    
    func update(mainText: String, rankText: String, backgroundColor: UIColor, score: Int) {
        configure(mainText: mainText, rankText: rankText, backgroundColor: backgroundColor, score: score)
    }
}

Eu tenho um dataframe no qual nos são fornecidas as colunas x e y e entre elas eu quero esboçar um modelo de regressão. A ideia principal é que eu use o framework dash, pois de acordo com o teste chow, pode haver diferença entre dois modelos de regressão em valores de instância diferentes, com base no seguinte link: modelos dash

Eu escrevi o seguinte código:

import pandas as pd
from dash import Dash,html,dcc,callback,Output,Input
from sklearn.linear_model import LinearRegression
import plotly.express as px
data =pd.read_csv("regression.csv")
model =LinearRegression()
print(data)
app = Dash()

# Requires Dash 2.17.0 or later
app.layout = [
    html.H1(children='Our regression Model', style={'textAlign':'center'}),
    dcc.Dropdown(data.Year.unique(), '2004', id='dropdown-selection'),
    dcc.Graph(id='graph-content')
]

@callback(
    Output('graph-content', 'figure'),
    Input('dropdown-selection', 'value')
)
def  scatter_graph(value):
    selected =data[data.Year==value]
    return px.scatter(selected,x='x',y='y')
@callback(
    Output('graph-content', 'figure'),
    Input('dropdown-selection', 'value')
)
def  Regression_graph(value):
    selected =data[data.Year==value]
    X =selected['x'].values
    X =X.reshape(-1,1)
    y =selected['y'].values
    model.fit(X,y)
    y_predicted =model.predict(X)
    return px.line(selected,x='x',y=y_predicted)

if __name__ =='__main__':
    app.run(debug=True)

esta parte funciona bem:

@callback(
    Output('graph-content', 'figure'),
    Input('dropdown-selection', 'value')
)
def  scatter_graph(value):
    selected =data[data.Year==value]
    return px.scatter(selected,x='x',y='y')

mas o segundo decorador para o gráfico de regressão não funciona, aqui está um exemplo:

por favor me ajude como consertar isso?

O objetivo da tarefa era inicializar uma lista vazia chamada rand_array e preenchê-la com 10 números aleatórios exclusivos

Eu descobri a tarefa normalmente, seguindo as instruções do professor:

import random

rand_array = []
while len(rand_array) != 10:
    lmnt = random.randint(1, 15)
    if lmnt not in rand_array:
        rand_array.append(lmnt)

print(rand_array)

Modifiquei-o mais tarde para ter inline para torná-lo mais eficiente, já que meu professor não gostava que eu usasse inline:

import random

rand_array = []
while len(rand_array) < 10:
    lmnt = random.randint(1, 15)
    rand_array.append(lmnt) if lmnt not in rand_array else None

Comecei a me questionar se isso seria realmente mais eficiente e se eu ainda conseguiria melhorar removendo a necessidade de inicializar uma lista vazia. Então, a pergunta principal é: "A segunda versão é mais eficiente que a primeira?" e também "Posso tornar a segunda versão ainda mais eficiente?"

Além disso, antes que alguém diga "Essa é uma tarefa tão pequena, não importa", se eu usar muito código embutido no futuro, preciso saber se a maneira como estou usando é mais eficiente do que o código não embutido.

Também peço desculpas antecipadamente se algo que digitei estiver impreciso.

Então, eu queria programar um flipbook interativo para mostrar o design da minha revista, mas o flipbook só funciona quando entro no modo Inspecionar Elemento ou quando abro meu site no celular. Sou iniciante em programação e usei turn.js para obter o efeito de flip.

Aqui está meu código JS para a página da web

// Load navbar and footer into every page
document.addEventListener("DOMContentLoaded", () => {
    // Load the navbar
    fetch("navbar.html")
        .then((res) => res.text())
        .then((data) => {
            document.getElementById("navbar").innerHTML = data;
        });

    // Load the footer
    fetch("footer.html")
        .then((res) => res.text())
        .then((data) => {
            document.getElementById("footer").innerHTML = data;
        });

    // Wait for the DOM to fully load before initializing Turn.js
    const flipbook = document.querySelector(".flipbook");

    // Ensure the flipbook exists before initializing Turn.js
    if (flipbook) {
        const initializeFlipbook = () => {
            const screenWidth = window.innerWidth;

            // Adjust flipbook size based on screen width
            let flipbookWidth = 800;
            let flipbookHeight = 500; // Default aspect ratio: 16:10

            if (screenWidth <= 768) {
                flipbookWidth = 600;
                flipbookHeight = flipbookWidth * 0.625; // Maintain aspect ratio
            }

            if (screenWidth <= 480) {
                flipbookWidth = 320;
                flipbookHeight = flipbookWidth * 0.625; // Maintain aspect ratio
            }

            // Set the container's dimensions
            const flipbookContainer = document.querySelector(".flipbook-container");
            flipbookContainer.style.width = `${flipbookWidth}px`;
            flipbookContainer.style.height = `${flipbookHeight}px`;

            // Force reflow
            flipbook.offsetHeight;

            // Initialize Turn.js
            $(flipbook).turn({
                width: flipbookWidth,
                height: flipbookHeight,
                autoCenter: true,
                elevation: 50,
                gradients: true,
                when: {
                    turning: function (event, page, view) {
                        console.log("Turning to page:", page);
                    },
                },
            });
        };

        // Initialize the flipbook
        initializeFlipbook();

        // Reinitialize the flipbook on window resize
        window.addEventListener("resize", () => {
            if ($(flipbook).data("turn")) {
                $(flipbook).turn("destroy"); // Destroy the existing flipbook
            }
            initializeFlipbook(); // Reinitialize with new dimensions
        });
    }
    $(flipbook).turn({
        width: flipbookWidth,
        height: flipbookHeight,
        autoCenter: true,
        elevation: 50,
        gradients: true,
        when: {
            turning: function (event, page, view) {
                console.log("Turning to page:", page);
            },
        },
    });
    console.log("Turn.js initialized!");
    
});

Aqui está meu repositório github, caso ajude: https://github.com/iiRosie1/portfolio

E a página da web para você ver como está quebrada agora: https://iirosie1.github.io/portfolio/brandmagazine.html

Qualquer ajuda é bem-vinda!

Estou tentando reexportar uma caixa de terceiros para que os consumidores da minha biblioteca não precisem adicionar manualmente todas as dependências necessárias para algum código gerado via macro proc.

No entanto, não consigo encontrar o caminho para resolver o compilador, mesmo obtendo conclusões de código para navegar até esse caminho.

Como posso reexportar corretamente caixas de terceiros de uma caixa minha, para que os consumidores das minhas caixas que utilizam minhas macros proc não precisem adicionar manualmente caixas de terceiros para dar suporte ao código gerado?

Abaixo está um exemplo simplificado que deve ser equivalente ao meu problema, embora meu projeto real tenha problemas para resolver esse caminho no código gerado pela minha própria macro proc.

Estrutura do arquivo:

│   Cargo.lock
│   Cargo.toml
│   rust-toolchain.toml
│
├───consumer
│   │   .gitignore
│   │   Cargo.toml
│   │
│   └───src
│           main.rs
│
└───exporter
    │   .gitignore
    │   Cargo.toml
    │
    └───src
            lib.rs

Na minha caixa "consumidor", tentei usar a Debugmacro derive fornecida pela derive_morecaixa.

Main.rs no consumidor:

#[derive(exporter::reexports::derive_more::Debug)]
pub struct Foo {
    x: u64
}


fn main() {
    println!("Hello, world!");
}

Cargo.toml no consumidor:

[package]
name = "consumer"
version = "0.1.0"
edition = "2021"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]
exporter = { path = "../exporter" }

lib.rs no exportador:

pub mod reexports {
    pub use derive_more;
}

Cargo.toml no exportador:

[package]
name = "exporter"
version = "0.1.0"
edition = "2021"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]
derive_more = { version = "2", features = ["full"] }

O contexto (mas não é uma questão exclusiva do Django) é que o servidor de teste do Django não retorna um esquema ou netloc em suas URLs de resposta e solicitação.

Eu pego /foo/barpor exemplo, e quero terminar com http://localhost:8000/foo/bar.

urllib.parse.urlparse (mas não tanto urllib.parse.urlsplit) facilita a coleta de informações relevantes, a partir da URL de teste e do endereço do meu servidor conhecido. O que parece mais complicado do que o necessário é recompor uma nova URL com o esquema e o netloc adicionados via urllib.parse.urlcompose , que precisa de argumentos posicionais, mas não documenta quais são, nem suporta argumentos nomeados. Enquanto isso, as funções de análise retornam tuplas imutáveis...

def urlunparse(components):
    """Put a parsed URL back together again.  This may result in a ..."""

Consegui fazer funcionar, veja o código abaixo, mas parece muito desajeitado, na parte em que preciso primeiro transformar as tuplas de análise em listas e depois modificar a lista na posição de índice necessária.

Existe uma maneira mais pitônica?

código de exemplo:

from urllib.parse import urlsplit, parse_qs, urlunparse, urlparse, urlencode, ParseResult, SplitResult

server_at_ = "http://localhost:8000"
url_in = "/foo/bar"  # this comes from Django test framework I want to change this to "http://localhost:8000/foo/bar"

from_server = urlparse(server_at_)
print("  scheme and netloc from server:",from_server)


print(f"{url_in=}")
from_urlparse = urlparse(url_in)

print("  missing scheme and netloc:",from_urlparse)

#this works
print("I can rebuild it unchanged :",urlunparse(from_urlparse))

#however, using the modern urlsplit doesnt work (I didn't know about urlunsplit when asking)
try:
    print("using urlsplit", urlunparse(urlsplit(url_in)))
#pragma: no cover pylint: disable=unused-variable
except (Exception,) as e: 
    print("no luck with urlsplit though:", e)


#let's modify the urlparse results to add the scheme and netloc
try:
    from_urlparse.scheme = from_server.scheme
    from_urlparse.netloc = from_server.netloc
    new_url = urlunparse(from_urlparse)
except (Exception,) as e: 
    print("can't modify tuples:", e)


# UGGGH, this works, but is there a better way?
parts = [v for v in from_urlparse]
parts[0] = from_server.scheme
parts[1] = from_server.netloc

print("finally:",urlunparse(parts))

saída de exemplo:

  scheme and netloc from server: ParseResult(scheme='http', netloc='localhost:8000', path='', params='', query='', fragment='')
url_in='/foo/bar'
  missing scheme and netloc: ParseResult(scheme='', netloc='', path='/foo/bar', params='', query='', fragment='')
I can rebuild it unchanged : /foo/bar
no luck with urlsplit though: not enough values to unpack (expected 7, got 6)
can't modify tuples: can't set attribute
finally: http://localhost:8000/foo/bar

Estou integrando o SDK JavaScript do PayPal ao meu aplicativo React + TypeScript usando o pacote @paypal/react-paypal-js. Meu objetivo é exibir o botão do PayPal com o logotipo "PP", conforme mostrado na documentação do PayPal: https://developer.paypal.com/sdk/js/reference/#label Resultado esperado

No entanto, apesar das várias configurações, o botão exibe apenas o texto "PayPal" sem o logotipo "PP": Resultado real

Tentei:

• Definindo rótulos no estilo do botão.
• Ajustando estilos de botões: layout, cor, formato e altura.
• Garantir que o contêiner tenha largura suficiente.

<PayPalButtons
    style={{
        color: 'gold',
        layout: 'horizontal',
        shape: 'pill',
        label: 'paypal',
        tagline: false,
        height: 40,
    }}
    onApprove={onApprove}
    onError={onErrorFunc}
    onCancel={onCancelFunc}
/>