Selecionei um subconjunto de colunas numéricas de um banco de dados e quero iterar pelas colunas, selecionando uma target_columne comparando-a com o resultado de uma operação numérica entre duas outras colunas no dataframe. No entanto, não tenho certeza de como comparar o resultado (por exemplo, col1 * col2 = target_column).

# For all possible combinations of numeric columns
for col1, col2 in combinations(numeric_cols, 2):
    # For a target column in numeric_columns
    for target_column in numeric_cols:
        # Skip if the target column is one of the relationship columns
        if target_column in (col1, col2):
            continue

Editar : Eu descobri algo, mas ainda não tenho certeza se esta é a maneira mais eficiente de fazer isso

def analyse_relationships(df):

numeric_cols = df.select_dtypes(include=[np.number])
threshold = 0.001
relationships = []

# For all possible combinations of numeric columns
for col1, col2 in combinations(numeric_cols, 2):
    # For a target column in numeric_columns
    for target_column in numeric_cols:
        # Skip if the target column is one of the relationship columns
        if target_column in (col1, col2):
            continue

        # Calculate different operations
        product = numeric_cols[col1] * numeric_cols[col2]
        sum_cols = numeric_cols[col1] + numeric_cols[col2]
        diff = numeric_cols[col1] - numeric_cols[col2]

        if np.allclose(product, numeric_cols[target_column], rtol=threshold):
            relationships.append(f"{col1} * {col2} = {target_column}")
        elif np.allclose(sum_cols, numeric_cols[target_column], rtol=threshold):
            relationships.append(f"{col1} + {col2} = {target_column}")
        elif np.allclose(diff, numeric_cols[target_column], rtol=threshold):
            relationships.append(f"{col1} - {col2} = {target_column}")

Qual é a complexidade de tempo do seguinte código em C#?

array.Order().Take(k).ToArray();

O LINQ tratará isso como QuickSelect? Ou realizará uma ordenação completa de arrays com complexidade O(n log n) ?

Usando ggplot2, gostaria de ter duas legendas na mesma linha, abaixo do título, mas uma alinhada à esquerda e outra alinhada à direita para um gráfico facetado como o abaixo.

Posso ter uma legenda alinhada à esquerda:

p <- ggplot(mtcars, aes(mpg, hp)) + 
  geom_point() +
  facet_grid(am~.) +
  theme(plot.title=element_text(hjust=0.5))

p + labs(title="Data: mtcars", subtitle="Subtitle (left-aligned)")

ou alinhado à direita,

p + labs(title="Data: mtcars", subtitle="Subtitle (right-aligned)") +
  theme(plot.subtitle=element_text(hjust=1))

Mas parece que não consigo ter os dois, a menos que eu os combine com um número arbitrariamente grande de espaços entre eles (que é como eu fiz o gráfico acima). Mas não gosto dessa solução. Existe outra maneira?

Como obtenho o hash MD5 do arquivo no Windows usando a linha de comando? Quero apenas o hash MD5 bruto, sem todo o texto extra. Tentei perguntar ao chatgpt, mas ele me deu um comando parcialmente funcional.

for /f "skip=1 tokens=1" %a in ('certutil -hashfile "path\to\your\file" MD5') do @echo %a & goto :done

Ele ainda imprime o CertUtil: -hashfile command completed successfully.que eu não quero que apareça

Em C++, por que uma classe derivada não pode chamar direta e explicitamente o destruidor de sua classe base sem usar um operador de resolução de escopo?

Ouvi dizer que em C++ todos os destruidores são processados ​​pelo compilador em "destrutor", o que significa que os destruidores das classes base e derivadas têm o mesmo nome, levando à redefinição (ocultação).

Isso está correto?

#include <iostream>
 
struct base {
    base() { std::cout << "base default \n"; }
    ~base() { std::cout << "~base \n"; }
};
 
struct derived : base {
    derived() { std::cout << "derived default \n"; }
    ~derived()
    {
        //~base();No
        base::~base();
        std::cout << "~derived \n";
    }
};

Eu sei que na prática quase não há necessidade de fazer isso, só quero entender o princípio...

Tento me familiarizar com a simultaneidade do Swift, especialmente com o MainActor.

Eu criei para mim esta classe de demonstração :

@MainActor
class ThreadsDemo {
  let range1000 = 0.. < 1000
  var randomNumber = 0

  init() {
    randomNumber = Int.random(in: range1000)
  }

  func modifyRandomNumber() async {
    print("2. isMain: \(Thread.isMainThread)")
    let newRandomNumber = Int.random(in: range1000)
    print("Generated random-number -> \(newRandomNumber)")
    Timer.scheduledTimer(withTimeInterval: 3.0, repeats: false) {
      _ in
        print("4. isMain (within wait): \(Thread.isMainThread)")
    }
    print("5. isMain: \(Thread.isMainThread)")
    randomNumber = newRandomNumber
  }
}

Invocando o método ThreadDemo:

.task {
  print("1. isMain: \(Thread.isMainThread)")
  print("Initial random-number -> \(threadsDemo.randomNumber)")
  await threadsDemo.modifyRandomNumber()
  print("Modified random-number -> \(threadsDemo.randomNumber)")
  print("6. isMain: \(Thread.isMainThread)")
}

Resultado:

1. isMain: true
Initial random-number -> 455
2. isMain: true
Generated random-number -> 578
5. isMain: true
Modified random-number -> 578
6. isMain: true
4. isMain (within wait): true

Obviamente executa tudo no thread principal, até mesmo o bloco dentro do temporizador agendado.

Estou confuso, porque pensei que ele usaria threads em segundo plano para evitar que a interface do usuário travasse e parasse de responder.

Se ele executa tudo no thread principal de qualquer maneira, então qual é o propósito de usar tarefas?

Mas o que eu realmente tentei descobrir:

A anotação @MainActor resulta na execução de tudo no thread principal (todo o código executável) ou resulta apenas em fazer alterações no estado (atribuições, etc.), sempre no thread principal?

Estou enfrentando um problema ao salvar entidades com o Entity Framework Core 6 (sem migrações, banco de dados SQL Server).

Mesmo com o mapeamento explícito de chaves estrangeiras, o EF Core tenta inserir uma coluna que não existe na tabela ( PecaIdPeca), resultando em um erro de SQL.

Modelo:

public class OrcamentoPeca
{
    [Key]
    [Column("ID_OrcamentoPeca")]
    public int IdOrcamentoPeca { get; set; }

    [Column("ID_Orcamento")]
    public int IdOrcamento { get; set; }

    [Column("ID_Peca")]
    public int IdPeca { get; set; }

    [Column("Quantidade")]
    public int Quantidade { get; set; }

    // Propriedades de navegação (sem [ForeignKey] attribute)
    public virtual Orcamento Orcamento { get; set; }
    public virtual Peca Peca { get; set; }
}

Método de inserção:

[HttpPost]
public async Task<IActionResult> SalvarPecasSelecionadas(int IdOrcamento, List<int> PecasSelecionadas, Dictionary<int, int> Quantidades)
{
    foreach (var pecaId in PecasSelecionadas)
    {
        var quantidade = Quantidades.ContainsKey(pecaId) ? Quantidades[pecaId] : 0;

        if (quantidade > 0)
        {
            var orcamentoPeca = new OrcamentoPeca
            {
                IdOrcamento = IdOrcamento,
                IdPeca = pecaId,
                Quantidade = quantidade
            };

            _context.OrcamentoPeca.Add(orcamentoPeca);

            var peca = _context.Pecas.FirstOrDefault(p => p.IdPeca == pecaId);

            if (peca != null)
                peca.Stock -= quantidade;
        }
    }

    await _context.SaveChangesAsync();

    return RedirectToAction("DetalhesOrcamento", new { id = IdOrcamento });
}

Contexto do banco de dados:

modelBuilder.Entity<OrcamentoPeca>(entity =>
{
    entity.HasKey(e => e.IdOrcamentoPeca);
    entity.ToTable("OrcamentoPeca");
    entity.Property(e => e.IdOrcamentoPeca).HasColumnName("ID_OrcamentoPeca");
    entity.Property(e => e.IdOrcamento).HasColumnName("ID_Orcamento");
    entity.Property(e => e.IdPeca).HasColumnName("ID_Peca");
    entity.Property(e => e.Quantidade).HasColumnName("Quantidade");

    entity.HasOne(e => e.Orcamento)
        .WithMany(o => o.OrcamentoPecas)
        .HasForeignKey(e => e.IdOrcamento)
        .OnDelete(DeleteBehavior.Cascade);

    entity.HasOne(e => e.Peca)
        .WithMany()
        .HasForeignKey(e => e.IdPeca)
        .OnDelete(DeleteBehavior.Cascade);
});

Erro:

SqlException: Nome de coluna inválido 'PecaIdPeca'. Microsoft.Data.SqlClient.SqlCommand+<>c.b__211_0(Resultado da tarefa)

DbUpdateException: Ocorreu um erro ao salvar as alterações da entidade. Consulte a exceção interna para obter detalhes.

Microsoft.EntityFrameworkCore.Update.ReaderModificationCommandBatch.ExecuteAsync(conexão IRelationalConnection, token de cancelamento)

Código SQL gerado:

INSERT INTO [OrcamentoPeca] ([ID_Orcamento], [ID_Peca], [PecaIdPeca], [Quantidade])
OUTPUT INSERTED.[ID_OrcamentoPeca]
VALUES (@p0, @p1, @p2, @p3);

O mapeamento DbContextestá correto, a coluna PecaIdPecanão existe no banco de dados, limpei e reconstruí o projeto.

Qualquer ajuda será apreciada.

Gostaria de usar um dos spinners integrados, dcc.Loadingmas adicionar algum texto abaixo do spinner/carregador enquanto ele estiver ativo.

import time
import plotly.express as px
import dash_mantine_components as dmc
import dash
from dash import dcc, callback, Output, Input

dash.register_page(module=__name__)

layout = dmc.MantineProvider(
    children=[
        dmc.Select(
            id="dropdown",
            data=["bar", "scatter", "none"],
            value="bar",
        ),
        dcc.Loading(
            type="graph",
            children=dmc.Box(id="my_figure")
        )
    ]
)


@callback(
    Output("my_figure", "children"),
    Input("dropdown", "value")
)
def show_fig(value):
    if value == "bar":
        time.sleep(5)
        return dcc.Graph(figure=px.bar())
    elif value == "scatter":
        time.sleep(5)
        return dcc.Graph(figure=px.scatter())
    else:
        return []

Este código mostrará apenas o spinner "gráfico" sem nenhum texto. Posso adicionar texto ao spinner integrado sem usar o custom_spinnerargumento? Ou preciso recriar o spinner integrado, adicionar texto a ele e depois passá-lo para custom_spinner?

Estou tentando criar regras WAF personalizadas para permitir tráfego para URIs específicos. Esta implantação está sendo feita via Terraform.

O erro que estou recebendo é:

Application Gateway Web Application Firewall Policy Name: "waf-policy-prod-uksouth"): unexpected status 400 (400 Bad Request) with error: ApplicationGatewayFirewallMatchValueNoCollection: Custom Rule 'AllowAmexPay' does not have a valid collection match variable 'RequestUri' which support selector in its condition in context 'properties.customRules[2].matchConditions[0].matchVariables[0]'.
│ 
│   with azurerm_web_application_firewall_policy.waf_policy,
│   on application_gw.tf line 224, in resource "azurerm_web_application_firewall_policy" "waf_policy":
│  224: resource "azurerm_web_application_firewall_policy" "waf_policy" {

Arquivo TFVars:

custom_rules = [
    {
        name                    = "RecitePreferences"
        priority                = "70"
        enabled                 = true
        rule_type               = "MatchRule"
        variable_name           = "RequestCookies"
        selector                = "Recite.Preferences"
        operator                = "Any"
        action                  = "Allow"
    },
        {
        name                    = "CookieConsent"
        priority                = "71"
        enabled                 = true
        rule_type               = "MatchRule"
        variable_name           = "RequestCookies"
        selector                = "CookieConsent"
        operator                = "Any"
        action                  = "Allow"
    },
        {
        name                    = "AllowAmexPay"
        priority                = "80"
        enabled                 = true
        rule_type               = "MatchRule"
        variable_name           = "RequestUri"
        selector                = "/smart-card/amex-pay"
        operator                = "Contains"
        action                  = "Allow"
    },
        {
        name                    = "AllowAmexPayComplete"
        priority                = "81"
        enabled                 = true
        rule_type               = "MatchRule"
        variable_name           = "RequestUri"
        selector                = "/smart-card/amex-pay-complete"
        operator                = "Contains"
        action                  = "Allow"
    }
]

Arquivo Variables.tf:

variable "custom_rules" {
  type  = list(object({
    name                    = string
    priority                = string
    enabled                 = bool
    rule_type               = string
    variable_name           = string
    operator                = string
    selector                = string
    action                  = string
  }))
}

Configuração do Application Gateway:

resource "azurerm_web_application_firewall_policy" "waf_policy" {
  name                = "waf-policy-${var.general_environment}-${var.general_location}"
  resource_group_name = azurerm_resource_group.prod.name
  location            = azurerm_resource_group.prod.location

  policy_settings {
    enabled                     = true
    mode                        = "Detection"
    request_body_check          = false
    file_upload_limit_in_mb     = 100
    max_request_body_size_in_kb = 128
  }
  managed_rules {
    managed_rule_set {
      type    = "OWASP"
      version = "3.2"
      
      dynamic "rule_group_override" {
        for_each = var.rule_group_override
        content {
          rule_group_name = rule_group_override.key

          dynamic "rule" {
            for_each = rule_group_override.value
            content {
            id      = rule.value.id
            enabled = rule.value.enabled
          } 
        }
      }
    }
  }

    dynamic "exclusion" {
      for_each = var.exclusion

      content {
        match_variable          = exclusion.value["match_variable"]
        selector                = exclusion.value["selector"]
        selector_match_operator = exclusion.value["selector_match_operator"]
      }
    }
    managed_rule_set {
      type = "Microsoft_BotManagerRuleSet"
      version = "1.0"
    }
  }
    dynamic "custom_rules" {
      for_each = var.custom_rules

      content {
          name          = custom_rules.value["name"]
          enabled       = custom_rules.value["enabled"]
          priority      = custom_rules.value["priority"]
          rule_type     = custom_rules.value["rule_type"]
          action        = custom_rules.value["action"]
          match_conditions {
            operator     = custom_rules.value["operator"]
            match_variables {
              variable_name = custom_rules.value["variable_name"]
              selector      = custom_rules.value["selector"]
            }
          }
        } 
      }     
}

Só queria saber se existe uma maneira diferente/melhor de passar as variáveis, já que elas estão apresentando erros no Apply?

Abaixo está meu código com um círculo dentro de um elemento svg que eu quero renderizar através do jinja2 usando st.html no streamlit. O problema é que o contêiner está visível, mas o elemento svg não está. Ele está em branco. Veja o código abaixo.

<style>
html,body {
  height: 100%;
  background-color: #404040;
  margin: 0;
  display: flex;
  justify-content: center;
  align-items: center;
}

.container {
  display: flex;
  width: 500px;
  /* Extended width for pipe */
  height: 500px;
  border: 3px solid #EEEEEE;
  justify-content: center;
  align-items: center;
  border-radius: 20px;

}

.drawing {
  position: relative;
  width: 2000px;
  /* Extended width for pipe */
  height: 600px;
}

.circle-svg {
  width: 100%;
  height: 100%;
}

.c3 {
  fill: none;
  stroke: grey;
  stroke-width: 10;
}

</style>

<body>
  <div class="container">
    <div class="drawing">
      <svg viewBox="0 0 500 500" class="circle-svg">
                <!-- Circle -->
                <circle class="c3" cx="250" cy="250" r="198"></circle>
            </svg>
    </div>
  </div>
</body>

código python:

def cutting_dimention(html_content):
    # Directly use the HTML content without treating it as a file path
    template = Template(html_content)
    rendered_html = template.render()  # Render the HTML with Jinja2
    st.text(rendered_html)  # Display rendered HTML text
    st.html(rendered_html)  # Display rendered HTML as an HTML block in Streamlit

Chame a função com o conteúdo HTML

dimensão_de_corte(meu_círculo)