All perguntas(coding)

Quando clico no menu lateral, a barra de ferramentas fica oculta, mas todo o fundo é movido para cima.

var body: some View {
        NavigationStack {
            ZStack {
                VStack {
                    SlideView()
                    ButtonView()
                }
                SideMenuView(isShowing: $showMenu, selectedTab: $selectedTab)
            }
            .toolbar(showMenu ? .hidden : .visible, for: .navigationBar)
            .navigationTitle("HKSTBC")
            .navigationBarTitleDisplayMode(.inline)
            .toolbar {
                ToolbarItem(placement: .topBarLeading) {
                    Button(action: {
                        showMenu.toggle()
                    }, label: {
                        Image(systemName: "line.3.horizontal")
                    })
                }
            }
        }
    }

Acabei de colocar .navigationBarTitleDisplayMode(.inline), mas não funciona. Como faço para o plano de fundo parar de se mover para cima?

Posso usar drop_nans()a função para remover linhas com algumas ou todas as colunas definidas como nan.

Existe uma função equivalente para descartar linhas com todas as colunas tendo valor 0?

import polars as pl
df = pl.DataFrame({"a":[0, 0, 0, 0, 30], 
                   "b":[0, 0, 0, 0, 40],
                   "c":[0, 0, 0, 0, 50]})

>>> df

     a        b        c
   i64      i64      i64
  ------------------------
     0        0        0
     0        0        0
     0        0        0
     0        0        0
    30       40       50

Neste exemplo, gostaria de remover as primeiras 4 linhas do dataframe.

Então, eu queria definir o número de tarefas que o compilador Rust usa, e ouvi dizer que deveria estar em config.toml. Além disso, config.toml deveria estar em:

$CARGO_HOME/config.toml cujo padrão é:

Windows: %USERPROFILE%\.cargo\config.toml
Unix: $HOME/.cargo/config.toml

O mais próximo que tenho são três nomes de arquivos como este:

/home/meunome/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/cfg-expr-0.15.8/.cargo/config.toml

Não é esse, certo? Pelo que entendi, o Cargo procura por um config.toml no diretório atual e, em seguida, recursivamente, uma pasta acima até chegar à raiz. Nem sei o que ele está usando, pois não vejo um arquivo chamado config.toml e, de qualquer forma, a busca em todo o sistema só mostrou o que colei acima. Onde está esse arquivo config.toml? Dois dos arquivos config.toml são bem pequenos e definem algumas flags, e o que está em cfg-expr-0.15.8/.cargo se parece com:

[target.'cfg(all())']
rustflags = [
    # BEGIN - Embark standard lints v6 for Rust 1.55+
    # do not change or add/remove here, but one can add exceptions after this section
    # for more info see: <https://github.com/EmbarkStudios/rust-ecosystem/issues/59>
    "-Dunsafe_code",
    "-Wclippy::all",
    "-Wclippy::await_holding_lock",
    "-Wclippy::char_lit_as_u8",
    "-Wclippy::checked_conversions",
    "-Wclippy::dbg_macro",
    "-Wclippy::debug_assert_with_mut_call",
    "-Wclippy::doc_markdown",
    "-Wclippy::empty_enum",
    "-Wclippy::enum_glob_use",
    "-Wclippy::exit",
    "-Wclippy::expl_impl_clone_on_copy",
    "-Wclippy::explicit_deref_methods",
    "-Wclippy::explicit_into_iter_loop",
    "-Wclippy::fallible_impl_from",
    "-Wclippy::filter_map_next",
    "-Wclippy::flat_map_option",
    "-Wclippy::float_cmp_const",
    "-Wclippy::fn_params_excessive_bools",
    "-Wclippy::from_iter_instead_of_collect",
    "-Wclippy::if_let_mutex",
    "-Wclippy::implicit_clone",
    "-Wclippy::imprecise_flops",
    "-Wclippy::inefficient_to_string",
    "-Wclippy::invalid_upcast_comparisons",
    "-Wclippy::large_digit_groups",
    "-Wclippy::large_stack_arrays",
    "-Wclippy::large_types_passed_by_value",
    "-Wclippy::let_unit_value",
    "-Wclippy::linkedlist",
    "-Wclippy::lossy_float_literal",
    "-Wclippy::macro_use_imports",
    "-Wclippy::manual_ok_or",
    "-Wclippy::map_err_ignore",
    "-Wclippy::map_flatten",
    "-Wclippy::map_unwrap_or",
    "-Wclippy::match_on_vec_items",
    "-Wclippy::match_same_arms",
    "-Wclippy::match_wild_err_arm",
    "-Wclippy::match_wildcard_for_single_variants",
    "-Wclippy::mem_forget",
    "-Wclippy::mismatched_target_os",
    "-Wclippy::missing_enforced_import_renames",
    "-Wclippy::mut_mut",
    "-Wclippy::mutex_integer",
    "-Wclippy::needless_borrow",
    "-Wclippy::needless_continue",
    "-Wclippy::needless_for_each",
    "-Wclippy::option_option",
    "-Wclippy::path_buf_push_overwrite",
    "-Wclippy::ptr_as_ptr",
    "-Wclippy::rc_mutex",
    "-Wclippy::ref_option_ref",
    "-Wclippy::rest_pat_in_fully_bound_structs",
    "-Wclippy::same_functions_in_if_condition",
    "-Wclippy::semicolon_if_nothing_returned",
    "-Wclippy::single_match_else",
    "-Wclippy::string_add_assign",
    "-Wclippy::string_add",
    "-Wclippy::string_lit_as_bytes",
    "-Wclippy::string_to_string",
    "-Wclippy::todo",
    "-Wclippy::trait_duplication_in_bounds",
    "-Wclippy::unimplemented",
    "-Wclippy::unnested_or_patterns",
    "-Wclippy::unused_self",
    "-Wclippy::useless_transmute",
    "-Wclippy::verbose_file_reads",
    "-Wclippy::zero_sized_map_values",
    "-Wfuture_incompatible",
    "-Wnonstandard_style",
    "-Wrust_2018_idioms",
    # END - Embark standard lints v6 for Rust 1.55+

Editar: OK, descobri que o Cargo também procura por arquivos chamados apenas "config" sem o ".toml". Bem, na minha pasta pessoal do Cargo não há nenhum arquivo de configuração, apenas um monte de "config.yml" e "config.rs", junto com os três "config.toml" que mencionei, mas não está na pasta pessoal do Cargo, está em algum caminho longo.

Tenho muito texto que está em um arquivo CSV com o seguinte formato.

ab(cd)(ef)ghi

Em cada linha, esse texto existe inúmeras vezes e há cerca de 2 a 3.000 linhas no arquivo de texto.

O que estou tentando fazer é substituir esse texto pelo seguinte formato.

abcdghi, abefghi

Atualmente, estou testando o método manual (edição entre colchetes) em um Mac.

Alguma sugestão? Um código simples de manipulação de texto ou um código baseado em PHP são muito bem-vindos.

Agradeço antecipadamente a sua ajuda

Tenho listas no meu site do SharePoint conectadas entre si. Um item é criado nessas listas quando um usuário cria um projeto no nosso PowerApp. Preciso excluir uma das entradas do projeto, mas estou recebendo o seguinte erro:

salvar conflito. suas alterações entram em conflito com aquelas feitas simultaneamente por outro usuário. se quiser que suas alterações sejam aplicadas, clique novamente no seu navegador, atualize a página e reenvie suas alterações.

Fechei todos os navegadores, executei-o no modo anônimo e como administrador do site, mas ainda continuo recebendo o mesmo erro. Alguém pode me dar um conselho?

Tenho um Polars DataFrame abaixo.

import polars as pl
df = pl.DataFrame({"a":["1.2", "2.3", "5.4"], 
                   "b":["0.4", "0.03", "0.12"],
                   "c":["AA", "BB", "CC"]})

>>> df
     a        b          c
    str      str       str
  -------------------------
  "1.2"    "0.04"      "AA"
  "2.3"    "0.3"       "BB"
  "3.5"    "0.12"      "CC"

Como posso converter as colunas para tipos específicos? Neste caso, quero converter colunas ae bem floats.

Espero abaixo.

>>> df
    a        b          c
   f64      f64       str
  ------------------------
  1.2      0.04      "AA"
  2.3      0.3       "BB"
  3.5      0.12      "CC"

Esta é a minha situação: estou tentando implantar uma instância legada do Azure Frontdoor na nova versão do AFD e fazer isso via Terraform.

Aqui está um trecho do meu bloco locals para a política de Firewall:

firewall_policy = {
    policy = {
      name     = "policy"
      sku_name = "AzureSKU"
      mode     = "prevention"
      managed_rules_list = [
        {
          type    = "Microsoft_DefaultRuleSet"
          version = "1.1"
          action  = "Block"
          exclusion = [
            {
              match_variable = "QueryStringArgNames"
              operator       = "Contains"
              selector       = "string1"
            },
            {
              match_variable = "RequestBodyPostArgNames"
              operator       = "StartsWith"
              selector       = "string2"
            },
            {
              match_variable = "RequestCookieNames"
              operator       = "EqualsAny"
              selector       = "string3"
            },
            {
              match_variable = "RequestBodyPostArgNames"
              operator       = "Contains"
              selector       = "string4"
            }
          ]
          override = [
            {
              rule_group_name = "RFI"
              rule = [
                {
                  rule_id = "931130"
                  action  = "Block"
                  exclusion = [
                    {
                      match_variable = "RequestBodyPostArgNames"
                      operator       = "Equals"
                      selector       = "string1"
                    },
                    {
                      match_variable = "QueryStringArgNames"
                      operator       = "Contains"
                      selector       = "string2"
                    },
                    {
                      match_variable = "QueryStringArgNames"
                      operator       = "Contains"
                      selector       = "string3"
                    },
                    {
                      match_variable = "QueryStringArgNames"
                      operator       = "Contains"
                      selector       = "string4"
                    }
                  ]
                }
              ]
            },
            {
              rule_group_name = "PHP"
              rule = [
                {
                  rule_id = "933100"
                  enabled = false
                  action  = "Block"
                },
                {
                  rule_id = "933110"
                  enabled = false
                  action  = "Block"
                },
                {
                  rule_id = "933120"
                  enabled = false
                  action  = "Block"
                }
              ]
            }
          ]
        }
      ]
    }

}

Como você pode ver, há muitos objetos aninhados.

No meu arquivo main.tf, eu chamo o seguinte:

    module "Azure_FW_Policy_module" {
  for_each                                        = local.firewall_policy
  source                                          = "./frontdoorFirewallPolicy"
  cdn_frontdoor_firewall_policy_name              = each.value.name
  resource_group_name                             = var.resource_group_name
  sku_name                                        = each.value.sku_name
  mode                                            = each.value.mode
  managed_rules_list                              = each.value.managed_rules_list
  managed_rules_exclusion_list                    = each.value.managed_rules_list.exclusion
  managed_rules_overide_list                      = each.value.managed_rules_list.override
  managed_rules_overide_rule_list                 = each.value.managed_rules_list.override.rule
  managed_rules_overide_rule_exclusion_list       = each.value.managed_rules_list.override.rule.exclusion
  managed_rules_overide_rule_group_exclusion_list = each.value.managed_rules_list.override.exclusion
  custom_rules_list                               = each.value.custom_rules_list
  tags                                            = var.tags
}

O módulo em si tem vários blocos dinâmicos para acomodar as várias configurações e se parece com isso:

    resource "azurerm_cdn_frontdoor_firewall_policy" "cdn_frontdoor_firewall_policy" {
  name                              = var.cdn_frontdoor_firewall_policy_name
  resource_group_name               = var.resource_group_name
  sku_name                          = var.sku_name
  enabled                           = var.enabled
  mode                              = var.mode
  custom_block_response_status_code = var.custom_block_response_status_code
  custom_block_response_body        = var.custom_block_response_body
  request_body_check_enabled        = var.request_body_check_enabled
  tags                              = var.tags
  dynamic "managed_rule" {
    for_each = toset(var.managed_rules_list)
    content {
      type    = managed_rule.value["type"]
      version = managed_rule.value["version"]
      action  = managed_rule.value["action"]
      dynamic "exclusion" {
        for_each = toset(var.managed_rules_exclusion_list)
        content {
          match_variable = exclusion.value["match_variable"]
          operator       = exclusion.value["operator"]
          selector       = exclusion.value["selector"]
        }
      }
      dynamic "override" {
        for_each = toset(var.managed_rules_overide_list)
        content {
          rule_group_name = override.value["rule_group_name"]
          dynamic "rule" {
            for_each = toset(var.managed_rules_overide_rule_list)
            content {
              rule_id = rule.value["rule_id"]
              action  = rule.value["action"]
              dynamic "exclusion" {
                for_each = toset(var.managed_rules_overide_rule_exclusion_list)
                content {
                  match_variable = exclusion.value["match_variable"]
                  operator       = exclusion.value["operator"]
                  selector       = exclusion.value["selector"]
                }
              }
            }
          }
          dynamic "exclusion" {
            for_each = toset(var.managed_rules_overide_rule_group_exclusion_list)
            content {
              match_variable = exclusion.value["match_variable"]
              operator       = exclusion.value["operator"]
              selector       = exclusion.value["selector"]
            }
          }
        }
      }
    }
  }
  dynamic "custom_rule" {
    for_each = toset(var.custom_rules_list)
    content {
      name                           = custom_rule.value["name"]
      enabled                        = custom_rule.value["enabled"]
      priority                       = custom_rule.value["priority"]
      type                           = custom_rule.value["type"]
      action                         = custom_rule.value["action"]
      rate_limit_duration_in_minutes = custom_rule.value["rate_limit_duration_in_minutes"]
      rate_limit_threshold           = custom_rule.value["rate_limit_threshold"]
      match_condition {
        match_variable     = custom_rule.value["match_variable"]
        operator           = custom_rule.value["operator"]
        negation_condition = custom_rule.value["negation_condition"]
        match_values       = custom_rule.value["match_values"]
      }
    }
  }
}

Meu problema é que quando executo isso, recebo o seguinte erro:

"each.value.managed_rules_list é uma tupla com 1 elemento. Este valor não possui nenhum atributo."

Com base na minha leitura, acredito que isso ocorre porque preciso usar o comando flatten no Terraform no elemento firewall_policy para passar isso ao módulo:

Como aqui

Entretanto, apesar de ler o acima, não tenho certeza de como exatamente devo chamar flatten para contabilizar todos os objetos aninhados e como posso passá-los para meu módulo, pois nunca usei isso antes.

Ao criar um endpoint de API no console da AWS, existem duas opções:

Opção A : Uma "API REST" com "tipo de endpoint de API" "Regional", "Otimizado para Edge" ou "privado". Minha dúvida é sobre a última opção ("privado").

Opção B : Uma "API REST Privada"

Aqui está uma captura de tela das opções:

Qual é a diferença entre as opções A e B? Parece que ambas só são acessíveis dentro da VPC da AWS. Estou esquecendo de algo?

Eu tenho um XML semelhante ao abaixo

<root>
<item>
<refitemid>10</refitemid>
</item>
</root>
    

meu requisito é primeiro adicionar um nó <additional_info> a, depois adicionar um novo nó a <additional_info> com base nos dados obtidos para que o novo XML seja apresentado como abaixo

<root>
<item>
<refitemid>10</refitemid>
<additional_info>
<sn><id>1</id></sn>
<sn><id>2</id></sn>
</additional_info>
</item>
</root>
    

Tentei fazer isso com o script abaixo.

def oPayload = new XmlSlurper().parseText(message.getBody() as String); //get above original XML data
if (oPayload.root.item.additional_info == "" || oPayload.root.item.additional_info == null) {
    oPayload.root.item.appendNode {
        additional_info {}
    }
}
for (int i = 1; i < 3; i++) {
    oPayload.root.item.additional_info.appendNode {
        sn {
            id(i.text())
        }
    }
}

oPayload = XmlUtil.serialize(oPayload)
    

infelizmente, o código acima não está funcionando, pois o resultado (no oPayload) será como abaixo:

<root>
<item>
<refitemid>10</refitemid>
</additional_info>
</item>
</root>
    

Você pode compartilhar sua ideia de como atingir o requisito? Muito obrigado.

Tenho um arquivo de cabeçalho que apresenta uma macro que declara uma estrutura Stack e algumas funções associadas que funcionam com essa estrutura. O conteúdo do arquivo de cabeçalho (Stack.h) é mostrado abaixo:

#ifndef STACK_H
#define STACK_H

#include <stddef.h> // size_t
#include <malloc.h> // malloc(), calloc()

#define STACK_DEFAULT_GROWTH_FACTOR 2.0
#define STACK_REALLOC_FAIL -1

#define DECL_STACK(T, Id) \
  typedef struct Stack_##Id { \
    size_t capacity; \
    size_t size; \
    float growth_factor; \
    T *data; \
  } Stack_##Id; \
  \
  Stack_##Id* Stack_##Id##_New(size_t capacity) { \
    Stack_##Id *p = malloc(sizeof(Stack_##Id)); \
    if (!p) return NULL; \
    T *d = calloc(capacity, sizeof(T)); \
    if (!d) { \
      free(p); \
      return NULL; \
    } \
    p->capacity = capacity; \
    p->size = 0; \
    p->growth_factor = STACK_DEFAULT_GROWTH_FACTOR; \
    p->data = d; \
    return p; \
  } \
  \
  void Stack_##Id##_Free(Stack_##Id *stack) { \
    free(stack->data); \
    free(stack); \
  } \
  \
  void Stack_##Id##_Push(Stack_##Id *stack, const T item) { \
    if (stack->size >= stack->capacity) { \
      size_t new_capacity = (size_t)(stack->capacity * stack->growth_factor); \
      T *d = realloc(stack->data, new_capacity); \
      if (!d) { \
        free(stack); \
        exit(STACK_REALLOC_FAIL); \
        return; \
      } \
      stack->capacity = new_capacity; \
    } \
    stack->data[stack->size++] = item; \
  } \
  \
  T Stack_##Id##_Pop(Stack_##Id *stack) { \
    return stack->data[--(stack->size)]; \
  } \
  \
  T Stack_##Id##_Peek(const Stack_##Id *stack) { \
    return stack->data[stack->size - 1]; \
  }

#endif // STACK_H

Tenho um arquivo Main.c que inclui Stack.h e outro arquivo de cabeçalho chamado Some.h. Some.h também inclui Stack.h para usar a macro mencionada para declarar uma função que utiliza a estrutura de pilha declarada de alguma forma. O arquivo Some.c fornece a definição da função de forma mais simples. Eu compilo e tento vincular o programa ao seguinte makefile:

objects = Main.o Some.o
CC = gcc
flags = -Wall -Wextra

Some.o : Some.c Some.h Stack.h
    $(CC) $(flags) -c Some.c Some.h Stack.h 

Main.o : Main.c Some.h Stack.h
    $(CC) $(flags) -c Main.c Some.h Stack.h

Main : $(objects)
    $(CC) $(objects) -o Main

clean: Main
    rm $(objects)

Aqui está o conteúdo de Main.c, Some.h e Some.c: Main.c:

#include <stdio.h>
#include "Stack.h"
#include "Some.h"

#ifndef STACK_INT
#define STACK_INT
DECL_STACK(int, int);
#endif

int main() {
  Stack_int *stack = Stack_int_New(10);
  Stack_int_Push(stack, 100);
  printf("%d\n", Stack_int_Peek(stack));
  Stack_int_Pop(stack);
  Use_stack(stack);
  Stack_int_Free(stack);
  return 0;
}

Alguns.h:

#include "Stack.h"
#include <stdio.h>

#ifndef STACK_INT
#define STACK_INT
DECL_STACK(int, int);
#endif

int Use_stack(Stack_int *stack);

Alguns.c:

#include "Some.h"

int Use_stack(Stack_int *stack) {
  Stack_int_Push(stack, 1);
  printf("%d\n", Stack_int_Peek(stack));
  Stack_int_Push(stack, 2);
  printf("%d\n", Stack_int_Peek(stack));
  Stack_int_Pop(stack);
  return Stack_int_Pop(stack);
}

Arquivos de objeto são compilados com sucesso, mas recebo um erro na etapa de vinculação que afirma que várias definições de função estão presentes para as funções Stack_int_New(), Stack_int_Free(), etc. Várias definições estão presentes apenas para funções, não para a própria struct Stack_int (o que me surpreende, na verdade). Eu esperava que as proteções de expansão de macro inseridas ao redor da macro DECL_STACK impedissem a expansão de múltiplas macros e, portanto, impediriam a redefinição da função (e da struct). Mas isso não aconteceu. Tentei remover os arquivos de cabeçalho das receitas de compilação no makefile, mas não ajudou. Com eles ou sem eles, o comando gcc Main.c/Some.c -Emostra que o pré-processador insere a macro e a expande de qualquer maneira. Como posso impedir a expansão de múltiplas macros se eu quiser incluir meu arquivo Stack.h em vários arquivos .c e declarar a pilha com o mesmo Id, ou seja, a mesma struct e funções para ela, mas sem que isso resulte em erros de vinculação?