Ao carregar um arquivo csv no pandas, encontrei a seguinte mensagem de erro:

DtypeWarning: Columns have mixed types. Specify dtype option on import  
or set low_memory=False

Lendo online encontrei algumas soluções.

Um, para definir low_memory=False, mas entendo que isso não é uma boa prática e não resolve realmente o problema.

A segunda solução é definir um tipo de dados para cada coluna (ou cada coluna com tipos de dados mistos):

pd.read_csv(csv_path_name, dtype={'first_column': 'str', 'second_column': 'str'})

Novamente, pelo que li, não é a solução ideal se tivermos um grande conjunto de dados.

Terceira solução: criar uma função conversora. No meu entender, esta pode ser a solução mais adequada. Encontrei um código que funciona para mim, mas estou tentando entender melhor o que essa função faz exatamente:

def convert_dtype(x):
    if not x:
        return ''
    try:
        return str(x)
    except:
        return ''

df = pd.read_csv(csv_path_name, converters={'first_col':convert_dtype, 'second_col':convert_dtype, etc.... } )

Alguém pode me explicar o código da função?

Obrigado

Você pode compartilhar algumas ideias de como encontrar pontos de curva (locais marcados em laranja) como mostrado na imagem:

Eu tentei este código:

result = []
    for i in range(len(df)):
        if i == 0 or df['y'].iloc[i] != df['y'].iloc[i - 1]:
            result.append(df.iloc[i])
            continue
        if i < len(df) - 1 and df['y'].iloc[i] != df['y'].iloc[i + 1]:
            result.append(df.iloc[i])

Mas o problema é que meu 'y' nem sempre é igual entre os pontos de interrupção e retorna muitos valores. Você poderia me dar alguma dica sobre como atingir meu objetivo?

Dados usados ​​para a imagem:

time = np.arange(0, 2200, 100)
values = np.array([-0.1, 0, 0.13, 0.27, 0.27, 0.4, 0.27, 0.27, 0.13, 0.13,
                   0.01, 0.01, -0.13, -0.13, -0.27, -0.4, -0.4, -0.27, -0.13, -0.13, 0, 0])

full_time = np.arange(0, 2200, 1)
full_values = np.interp(full_time, time, values)

Tenho refatorado usando o índice espacial em Haversine,

Eu queria escrever uma instrução SQL que verificasse postagens em um raio de 10 km com o valor de ponto (0,90) para obter informações sem distância, mas confirmei que o índice não é usado se 'ou' for usado.

Então, tentei combinar as duas consultas SELECT usando UNION ALL , mas o desempenho permaneceu tão lento quanto antes, tornando-o ineficaz. Testei isso com 50.000 linhas de dados e não houve melhora perceptível — mesmo com o índice espacial sendo usado corretamente neste caso.

Como último recurso, pensei em separar as postagens sem informações de distância das postagens com informações de distância para separar a API, mas a interface mudou e agora o front não consegue refatorar, então quero excluí-la o máximo possível. Obrigado 🙏

select b1_0.id,
   b1_0.title,
   b1_0.item_time,
   b1_0.item_price,
   b1_0.created_date,
   b1_0.chat_count,
   b1_0.scrap_count,
   st_distance_sphere(b1_0.location, ST_GeomFromText('POINT(127.0 37.5)', 4326)),
   b1_0.address,
   b1_0.board_state,
   (select i1_0.stored_file_name
    from image i1_0
    where i1_0.board_id = b1_0.id
    order by i1_0.id LIMIT 1)
from board b1_0
where b1_0.board_type = 'SELL'
  and (ST_Contains(ST_Buffer(ST_GeomFromText('POINT(127.0 37.5)', 4326), 0.1), b1_0.location)
           OR (latitude = 90.0 AND longitude = 0.0))
order by b1_0.created_date desc
limit 0, 8;

Tenho um aplicativo simples e brilhante onde um conjunto de dados é criado em uma reactive()chamada e depois plotado. Como a criação dos dados pode demorar um pouco, quero que ele seja chamado de assíncrono para que a sessão possa ser usada de outra forma. Para isso, quero usar shiny::ExtendedTask()with mirai.

Os documentos oficiais têm exemplos em que o task$invoke(...)é acionado por um botão (por exemplo, dentro de um shiny::observeEvent()), mas não há exemplos de como posso estruturar isso se minha função for acionada dentro de um reactive().

Observe que meu caso de uso real reutiliza os dados resultantes em alguns gráficos na página específica.

Aplicativo de sincronização MWE

O seguinte é um MWE para um aplicativo de bloqueio

library(shiny)
library(bslib)

create_data <- function(n) {
  Sys.sleep(2)
  data.frame(x = seq(n), y = rnorm(n))
}

ui <- page_fillable(
  card(
    card_header(span("To show reactive state, here is the current time ",
                     textOutput("current_time", inline = TRUE))),
    plotOutput("myplot")
  )
)

server <- function(input, output, session) {
  # note this reactive here should be put into an ExtendedTask
  data <- reactive({
    create_data(100)
  })
  
  output$myplot <- renderPlot({
    d <- data()
    plot(d$x, d$y)
  })

  
  # to show if the session is free: show current time
  output$current_time <- renderText({
    invalidateLater(1000, session)
    format(Sys.time(), "%H:%M:%S")
  })
  
}

shinyApp(ui, server)

Observe como a hora não é mostrada imediatamente porque a create_data()função bloqueia a sessão.

Tentativa de um aplicativo assíncrono

Para mostrar quando os eventos são acionados, movo o conteúdo para uma segunda página da barra de navegação. Portanto, espero que as tarefas sejam acionadas quando os dados forem necessários, pois a página é exibida (por exemplo, reactive()e não observe()o comportamento).

Minha tentativa malsucedida é então a seguinte (observe como eu aciono o task$invokecom um observe()este é o erro, mas não sei como eu acionaria isso com um reactive()ou de outra forma.

library(shiny)
library(bslib)
library(mirai)

create_data <- function(n) {
  Sys.sleep(2)
  data.frame(x = seq(n), y = rnorm(n))
}
# small helper function for logging
flog <- function(m) cat(sprintf("INFO [%s] | %s\n", format(Sys.time(), "%Y-%m-%d %H:%M:%OS3"), m))

ui <- page_navbar(
  nav_panel("Empty Default"),
  nav_panel(
    "Same as Before",
    card_header(span("To show reactive state, here is the current time ",
                     textOutput("current_time", inline = TRUE))),
    plotOutput("myplot")
  )
)

server <- function(input, output, session) {
  # create the task
  task <- ExtendedTask$new(function(...) mirai(fun(n = n), fun = create_data, ...))
  
  # this is the error here: the observe is not triggered by the rendered plot but by observe => fires immediately
  observe({
    flog("Task Invoke")
    task$invoke(n = 100)
    flog("Task Invoke Done")
  })
  
  output$myplot <- renderPlot({
    flog("Task Result")
    data <- task$result()
    flog("Task Result Done")
    
    plot(data$x, data$y)
  })
  
  
  # to show if the session is free: show current time
  output$current_time <- renderText({
    invalidateLater(1000, session)
    format(Sys.time(), "%H:%M:%S")
  })
}

shinyApp(ui, server)

Este aplicativo de exemplo, quando executado no macOS 15.4, exibe um comportamento de animação estranho ao abrir e fechar a barra lateral.

Tudo o que você precisa fazer para corrigir o problema é remover a .frame(minWidth: 805, minHeight: 525)linha, mas isso significa que você não pode limitar o tamanho da janela.

Gostaria de ter um tamanho mínimo para meu aplicativo, mas isso defaultSize()não funciona.

enum Page: String, Hashable {
    case settings = "Settings"
    case radio = "Radio"
    case connect = "Connect"
    
    var systemImageName: String {
        switch self {
        case .settings:
            return "gear"
        case .radio:
            return "radio"
        case .connect:
            return "dot.radiowaves.right"
        }
    }
}

struct ContentView: View {
    @State var pages = [Page.settings, Page.radio, Page.connect]
    
    var body: some View {
        NavigationSplitView {
            List(pages, id: \.self) { page in
                Label(page.rawValue.capitalized, systemImage: page.systemImageName)
            }
        } detail: {
            Text("Content")
        }
    }
}

@main
struct NavigationTestsApp: App {
    var body: some Scene {
        Window("Navigation", id: "H") {
            Group {
                ContentView()
                    // Without this line this animation bug does not happen
                    .frame(minWidth: 805, minHeight: 525)
            }
        }
    }
}

Digamos que eu tenha algo assim:

type TIn = {
    xa?: number;
    xb?: string;
    xc?: boolean;
    // ...
}

type TOut = {
    ya: number | undefined;
    yb: string | undefined;
    yc: TPerson | undefined;
    // ...
}

type TPerson = {
    name: string;
    age: number;
}

function fn(input: TIn): TOut {
    // ...
}

Agora, digamos que eu queira aplicar a verificação estática de nulidade dos campos de saída em relação à entrada. Por exemplo:

• quando xaé um number, o relacionado yatambém será um number;

• quando xaé undefined, yaserá também undefined;

• quando xbé um string, o relacionado ybpode ser um stringou undefined;

• quando xbé undefined, ybserá também undefined;

E assim por diante.

Em C#, há atributos especiais para instruir o compilador sobre como verificar estaticamente a nulidade.

https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/attributes/nullable-análise

Gostaria de saber se existe algum "substituto" (quero dizer, brincar com tipos e utilitários) no TypeScript para obter uma verificação de nulidade mais completa.

Além disso, não é uma solução personalizada "como este exemplo", mas sim uma ferramenta modular para usar em qualquer caso.

EDIT: Aqui está uma tentativa de resolver, não está funcionando, mas foi adicionada para maior clareza.

Abaixo estão os supostos ajudantes:

//maps TResult when T1 is not undefined
//undefined otheriwse
type TNotNull<T1, TResult> = T1 extends {}
    ? TResult
    : undefined;

//maps TResult | undefined when T1 is not undefined
//undefined otheriwse
type TMaybeNull<T1, TResult> = T1 extends {}
    ? TResult | undefined
    : undefined;

//maps TResult when both T1 and T2 are not undefined
//undefined otheriwse
type TNotNullWhenBoth<T1, T2, TResult> = T1 extends {}
    ? T2 extends {} ? TResult : undefined
    : undefined;

Poderia haver muito mais (mais argumentos, lógica mais complexa, etc.)

Agora, como exemplo, vamos definir o contrato de entrada da função:

type TIn = {
    a?: number;
    b?: number;
    s?: string;
}

Para o tipo de saída, a ideia é compô-lo usando os supostos auxiliares:

type TOut<T extends TIn> = {
    inv_a: TNotNull<T["a"], number>;
    flag: TMaybeNull<T["b"], boolean>;
    str: TNotNull<T["s"], string>;
    sum: TNotNullWhenBoth<T["a"], T["b"], number>;
}

Ou seja, para inv_a:

• quando aé um número, inv_atambém é um número
• quando aé indefinido, inv_atambém é indefinido

Para flag:

• quando bé um número, flagé um booleano ou indefinido
• quando bé indefinido, flagtambém é indefinido

Para str, similarmente a inv_a:

• quando sé uma string, strtambém é uma string
• quando sem indefinido, strtambém é indefinido

Para sum, mesma lógica que inv_a, mas dois argumentos AND-ed:

• quando ambos ae bsão números, sumtambém é um número
• sumserá indefinido caso contrário

Por fim, vamos escrever a função. Aqui, a implementação não é importante. Fora da função, precisamos apenas que o contrato de entrada/saída seja sempre satisfeito.

const flags: Array<boolean> = new Array(10);
flags[3] = true;

function fn(input: TIn): TOut<TIn> {
    const { a, b, s } = input;
    //just an example of implementation
    const inv_a = typeof a === "number"
        ? 1 / a
        : void 0;
    const flag = typeof b === "number"
        ? flags[b]
        : void 0;
    const str = typeof s === "string"
        ? s + "hello!"
        : void 0;
    const sum = typeof a === "number" && typeof b === "number"
        ? a + b
        : void 0;
    return { inv_a, flag, str, sum }
}

Neste ponto, aqui estão alguns casos de uso e como a inferência de resultados é esperada:

//expected inference: all undefined
//actual inference: inv_a:number|undefined; flag:boolean|undefined; etc
const { inv_a, flag, str, sum } = fn({});

//expected inference: flag:boolean | undefined; rest undefined
//actual inference: inv_a:number|undefined; flag:boolean|undefined; etc
const { inv_a, flag, str, sum } = fn({ b: 3 });

//expected inference: inv_a:number; str:string; flag, sum:undefined
//actual inference: inv_a:number|undefined; flag:boolean|undefined; etc
const { inv_a, flag, str, sum } = fn({ a: 5, s: "xyz" });

//expected inference: inv_a, sum:number; flag, str:undefined
//actual inference: inv_a:number|undefined; flag:boolean|undefined; etc
const { inv_a, flag, str, sum } = fn({ a: 5, b: 3 });

Infelizmente, não funciona.

Quero dividir um arquivo de recursos do k8s com mikefarah/yq em arquivos individuais por recurso. Obviamente, o nome do arquivo de destino dos novos arquivos precisa ser dinâmico.

Um esquema de nomenclatura bastante óbvio para recursos k8s é [nome-do-tipo]. Então, cheguei a este comando.

 yq '.items[]' my-file.yaml -s '.kind + "-" + .metadata.name'

Mas o nome do k8s pode conter caracteres como dois pontos, que não são permitidos em um nome de arquivo. Se isso acontecer, recebo este erro

Erro: abra ClusterRole-system:[...].yml: A sintaxe do nome do arquivo, nome do diretório ou rótulo do volume está incorreta.

Existe uma maneira de substituir caracteres no nome do arquivo de destino dinâmico?

Gostaria de criar um Diagrama de Venn com sf+ ggplot2pacotes.

Como alterar manualmente as cores dos círculos e as regiões de intersecção dos dois círculos internos? Alterar a escala de preenchimento {ggplot2}não afeta as cores dos círculos.

Inicialização

library(ggplot2)
library(dplyr)
library(sf)

create_circle_sf <- function(x, y, radius, label, fill_id) {
  st_point(c(x, y)) %>%
    st_buffer(radius) %>%
    st_sfc(crs = 4326) %>%
    st_sf(label = label, fill_id = fill_id, geometry = .)
}



# radii from n values
r1 <- sqrt(6000 / pi)
r2 <- sqrt(2000 / pi)
r3 <- sqrt(2000 / pi)


# Add a new `fill_id` for color mapping
circle1 <- create_circle_sf(0, 0, r1, "Party Representatives", "A")
circle2 <- create_circle_sf(14, 0, r2, "Unique parties", "B")
circle3 <- create_circle_sf(-13, 0, r3, "Client Companies", "C")

# Combine all
circles_all <- bind_rows(circle1, circle2, circle3)
# calculate intersection (e.g., between 1 & 2)
intersect12 <- st_intersection(circle1, circle2)
intersect13 <- st_intersection(circle1, circle3)
intersect23 <- st_intersection(circle2, circle3)
# combine all
circles_all <- bind_rows(circle1, circle2, circle3)

Tentativa de enredo

# Define color manually for each fill_id
custom_colors <- c("A" = "#77bca2", "B" = "#FFEB3B", "C" = "#FF9800")
# Circle centers and labels
label_df <- data.frame(
  x = c(0, 14, -13),
  y = c(0, 0, 0),
  label = c("Party Representatives: 41",
            paste0("Unique\n Parties: ", 20),
            paste0("Unique\nClient\nCompanies: ", 30))
)

ggplot() +
  geom_sf(data = circles_all, aes(fill = fill_id), alpha = 0.8) +  
  # use fill_id here
  geom_sf(data = intersect12, fill = "white", alpha = 0.8) +
  geom_sf(data = intersect13, fill = "white", alpha = 0.8) +
  geom_sf(data = intersect23, fill = "white", alpha = 0.8) +
  geom_text(data = label_df, aes(x = x, y = y, label = label),
            size = 4.5, fontface = "bold", lineheight = 0.9) +
  scale_fill_manual(values = custom_colors) +
  theme_void() +
  coord_sf() +
  theme(legend.position = "none")

Estou tentando renderizar a página do Suitelet como um PDF. É possível chamar a URL do Suitelet no modelo PDF avançado e exibir o design do Suitelet como um PDF? Como isso é possível?

Atualmente estou testando um modelo avançado de PDF para pedido de vendas.

O programa a seguir está incorreto ,

inline constexpr auto makeFoo = [](auto const& x) {
    return getFoo(x);
};

inline constexpr auto getFoo = [](int const&) {
    return 1;
};

int bar() {
    return makeFoo(32);
}

e reverter as definições de makeFooe getFootorna-o correto .

Entendo que, com base no entendimento "informal" da pesquisa de nomes em duas fases:

• makeFooé um lambda genérico e, getFooem seu corpo, é invocado em um argumento cujo tipo ainda não é conhecido, então o nome getFooainda não pode ser consultado;
• quando a chamada makeFoo(32)é vista, o lambda operator()é intantiado com auto = int, então a busca de segunda fase pelo nome não qualificado getFooacontece;
• isso, no entanto, é apenas ADL, então não encontra getFoo, porque esse é o nome de um lambda, ou seja, um objeto, não de uma função.

Alguém pode me orientar sobre as partes do rascunho padrão que "espelham" a explicação acima?

Suponho que [basic.lookup.unqual] e [temp.dep.res] possivelmente contenham tudo o que é necessário para explicar o caso, mas não consigo juntar as peças.