mike rodent's questions

Já li muitas explicações sobre o que git diffacontece entre dois commits e ainda estou completamente perplexo com o resultado que estou obtendo. Acredito que o que estou vendo seja o "formato combinado", considerado o formato "padrão", mas, se for esse o caso, não sei quais outros formatos estão disponíveis.

Exemplo:

>git diff af738ab0..bbbec26d > gitdiff_2025-04-09B.diff

Geralmente recebo esse tipo de coisa:

...
+diff --git a/src/core/history_table_view.py b/src/core/history_table_view.py
+index 5b18236..05b262a 100644
+--- a/src/core/history_table_view.py
++++ b/src/core/history_table_view.py
+@@ -14,188 +14,279 @@ class HistoryTableView(QtWidgets.QTableView):
+     @thread_check(True)
+     def __init__(self, *args):
+         super().__init__(*args)
+-        self.setObjectName('history table')
+-        self.setSelectionMode(QtWidgets.QAbstractItemView.SingleSelection)
+-        self.horizontalHeader().setStretchLastSection(True)
+-        self.horizontalHeader().hide()
+-        self.verticalHeader().hide()
+-        self.setModel(HistoryTableModel(self))
...

... nesta parte da saída, ele está comparando o arquivo history_table_view.py no primeiro commit com o mesmo arquivo no segundo commit.

Todas as linhas acima estão presentes em ambos os arquivos. Então, por que essa linha pode

+     def __init__(self, *args):    

comece com um simples "+", enquanto esta linha

+-        self.setObjectName('history table')

começa com "+-"? O que isso significa? Como eu disse, ambas as linhas estão presentes em ambas as versões deste arquivo. Eu esperaria, git diffa princípio, que nenhuma dessas linhas fosse exibida (embora haja algumas diferenças em termos de linhas vazias entre as linhas com texto).

Em segundo lugar, quando assisto a uma introdução simples git diff, como esta , o apresentador faz git diffdois commits, aos 4:40 do vídeo vemos a saída... mas no caso dele ele NÃO está vendo símbolos duplos no início das linhas, mas sim simples "+" ou "-", ou seja, até onde eu entendo, o que se poderia esperar de um diffcomando BASH feito entre dois arquivos. ESSE FORMATO SIMPLES É TUDO O QUE EU QUERO.

Suspeito que possa haver uma alternativa ao git diff"formato combinado" que de fato produza essa saída mais simples, mas não consegui encontrá-la. Em segundo lugar, o vídeo que mencionei acima foi feito há 7 meses: por que aquele YouTuber está obtendo, por padrão, ao comparar dois commits, uma saída simples do Git (que é perfeitamente compreensível para mim), enquanto eu obtenho (para mim) uma saída incompreensível? Minha versão do Git é:

git version 2.48.1.windows.1

Um link simples para uma página que explique genuinamente essa questão específica de git diffcomparar dois commits, em termos claros e, principalmente, mostrando como obter um .exe simples diff, pode ser tudo o que preciso. Procurei muito e não encontrei.

Mais tarde .
O daoh-nvohter pode, por favor, dizer por que essa pergunta não vale a pena ser feita?

Estou tentando encontrar um algoritmo de tree walker "poderoso/versátil" não recursivo, que, em última análise, produza não apenas o nó, mas a profundidade do nó, seu índice pai e irmão, e seja capaz de usar uma busca em largura (BFS) ou busca em profundidade (DFS).

É possível combinar depth-first e bread-first assim, apenas produzindo o nó (NB assume um nó que pode ou não ter a chave CHILD_NODES). Exemplo usando Python - tag "Python" adicionada, mas obviamente não específica:

def get_walker(walk_by_depth=True):
    def walk(root):
        queue = [root]
        while len(queue) > 0:
            # the first item in the queue
            node_to_yield = queue.pop(0)

            yield node_to_yield

            if CHILD_NODES in node_to_yield:
                depth += 1    
                new_nodes = node_to_yield[CHILD_NODES]
                if walk_by_depth:
                    queue = new_nodes + queue
                else:
                    queue.extend(new_nodes)
    return walk

... e adicionar uma pequena quantidade de código permite que você obtenha uma profundidade somente para uma busca em largura :

def get_walker(walk_by_depth=True):
    def walk(root):
        queue = [root]
        depth = 0 
        depth_map_of_remaining_items = {0: 1}
        while len(queue) > 0:
            node_to_yield = queue.pop(0)
            if depth_map_of_remaining_items[depth] == 0:
                depth += 1
            depth_map_of_remaining_items[depth] -= 1

            yield node_to_yield, depth

            if CHILD_NODES in node_to_yield:
                depth += 1    
                new_nodes = node_to_yield[CHILD_NODES]
                if walk_by_depth:
                    queue = new_nodes + queue
                else:
                    queue.extend(new_nodes)
                    if depth not in depth_map_of_remaining_items:
                        depth_map_of_remaining_items[depth] = 0
                    depth_map_of_remaining_items[depth] += len(new_nodes)    
                depth -= 1
    return walk

O código acima não funciona de fato com walk_by_depth=True: ele não levanta uma Exception, ele apenas erra a profundidade. Instintivamente, tenho a sensação de que o código provavelmente só precisa de um ajuste mínimo para renderizar (corrigir) depthem um DFS, mas não tive sucesso até agora.

A questão é que, se eu puder encontrar uma maneira de produzir a profundidade com um DFS, acredito que será um passo bem fácil produzir, tanto para BFS quanto para DFS, o nó pai, mantendo um mapa "profundidade-para-último-nó". Se você puder obter o pai, também poderá obter o índice irmão, no máximo usando o método listde index(embora possa haver maneiras muito mais inteligentes de obter o índice pai e irmão...).

Estou usando o pytest. Nota W10.
Estarei executando meu aplicativo indo > python src/core. "core" é meu módulo central, com um __main__.pyarquivo.

Por esse motivo estou colocando meu diretório "testes" em [raiz do projeto]/src/core.

Eu tenho um arquivo de teste test_xxx.py. Nele tento importar __main__:

import __main__

... 

def test_xxxxx():
   print(f'main {__main__} type {type(__main__)}')

Isso imprime o seguinte:

main <module '__main__' from 'D:\\apps\\Python\\virtual_envs\\doc_indexer v2.0.0\\Scripts\\pytest.exe\\__main__.py'> type <class 'module'>

... em outras palavras, ele não está importando meu local __main__.pydo módulo "principal" local, mas o próprio pytest __main__de seu módulo. Até agora tudo compreensível. Então eu olho para sys.path:

path: D:\My Documents\software projects\EclipseWorkspace\doc_indexer\src\core\tests
path: D:\My Documents\software projects\EclipseWorkspace\doc_indexer\src\core
path: D:\apps\Python\virtual_envs\doc_indexer v2.0.0\Scripts\pytest.exe
path: D:\apps\Python\PyQt5
...

Agora estou coçando a cabeça, não pela primeira vez com o pytest. Este caminho ...src\core está listado antes de ...Scripts\pytest.exe. Por que o pytest identificaria o seu próprio __main__.pye o importaria, antes de importar __main__.pyde um caminho que o precede?

Eu também tentei vários experimentos com importlib. Nada parece funcionar.

Então, geralmente, existe alguma maneira de realmente importar esse arquivo ...src/core/ __main__py?

Sei que esse arquivo deve fazer coisas mínimas antes de passar para outro arquivo, mas para completar, gostaria apenas de testar se main()de fato faz isso. Existe alguma maneira de executar __main__.main()um teste?

Quero iterar Vecfazendo várias coisas com os objetos nele contidos (o que seria mais complexo que usizes) e, no caso de uma ordem para interromper a iteração, reter apenas os objetos que ainda não foram processados.

fn main() {
    let _ = iterate();
}

fn iterate(){
    let mut objs_for_processing = Vec::new();
    
    for i in 0..10 {
        objs_for_processing.push(i);
    }
    
    let mut n = 0;
    objs_for_processing.retain(|obj| {
        n += 1;
        if n > 3 {
            println!("STOP iteration!...");
            return true // i.e. retain
        }
        println!("iteration, do some business with obj {}", obj);
        false
    });
    println!("objs_for_processing.len() {} {:#?}", objs_for_processing.len(), objs_for_processing);
}

O problema acima, obviamente, é que você precisa completar todas as iterações, mesmo depois de saber que deseja manter todos os outros elementos...

Encontrei esta pergunta e esta pergunta . Este último parecia mais promissor. Mas acontece que você não pode alterar o tipo de retorno do retainfechamento de ' (ou seja, aceitar a Result, para poder retornar an Errque interromperá a iteração), até onde eu sei.

A única solução que encontrei é clonar o Vec, iterar usando um normal for ... ine depois remover itens do clone (chamado depleted_vec) à medida que são processados, usando o bastante complicado

let index = depleted_vec.iter().position(|x| x == obj).unwrap();
depleted_vec.remove(index);

... e depois atribuir objs_for_processinga depleted_vec. Pelo menos desta forma posso usar breakpara interromper a iteração.

Parece uma coisa bastante razoável de se fazer: não existe uma maneira mais elegante de fazer isso?

NB: Eu também me perguntei se poderia haver uma Iteratorsolução baseada em - então tentei com iter().filter(...).collect()... isso produz um Vecof &usize, not usize. Portanto, talvez pudesse ser usado, mas com custo de processamento adicional. Não é bonito: parece que deveria haver algo melhor.

Tenho usado "scroll" para obter sequências de dados de um índice ES (v 8.6.2) em Python.

Por vários motivos, quero mudar para fazer reqwestsolicitações em Rust (PyO3) em vez de requestssolicitações em Python. Meu primeiro pedido é assim:

let es_url = "https://localhost:9500"; // ES server is using this port
let data = json!({
    "size": 100,
    "query": {
        "bool": {
            "must": {
                "match_all": {}
            },
            "filter": [
                {
                    "term": {
                        "ldoc_type": "docx_doc"
                    }
                }
            ]
        }
    },
});
let data_string = serde_json::to_string(&data).unwrap();
let url = format!("{es_url}/{}/_search?scroll=1m", INDEX_NAME.read().unwrap());
let send_result = reqwest_client
.post(url)
.header("Content-type", "application/json")
.body(data_string)
.basic_auth("mike12", Some("mike12"))
.send(); 
let response = match send_result {
    Ok(response) => response,
    Err(e) => {
        error!("SEND error was {}", e);
        return false
    },
};
let text = match response.text() {
    Ok(text) => text,
    Err(e) => {
        error!("TEXT error was {}", e);
        return false
    },
};
let json_hashmap: HashMap<String, Value> = serde_json::from_str(&text).unwrap();
let scroll_id = &json_hashmap["_scroll_id"];
let scroll_id_str = scroll_id.to_string();
let scroll_id_str = rem_first_and_last(&scroll_id_str); // strip "\"" either side
info!("|{:#?}| type {}", scroll_id_str, utilities::str_type_of(&scroll_id_str));

... isso mostra o &str"ID de rolagem" retornado. Um exemplo típico é:

"=="

... isso é estranho, porque essa string de ID é cerca de 4 vezes maior que a string de ID que recebo quando uso Python. Mas a string acima, embora pareça ter um certo caráter repetitivo, não é na verdade uma repetição de uma string menor.

Depois disso, para fazer solicitações repetidas para obter mais lotes de 100 acessos, faço o seguinte:

let mut n_loops = 0;
loop {
    n_loops += 1;
    let data = json!({
        "scroll": "1m",
        "scroll_id": scroll_id_str,
    });
    let data_string = serde_json::to_string(&data).unwrap();
    let url = format!("{es_url}/_search?scroll");
    let send_result = reqwest_client
    .post(url)
    .header("Content-type", "application/json")
    .body(data_string)
    .basic_auth("mike12", Some("mike12"))
    .send(); 
    let response = match send_result {
        Ok(response) => response,
        Err(e) => {
            error!("SEND error was {}", e);
            return false
        },
    };
    info!("response {:?} type {}", response, utilities::str_type_of(&response));
    let response_status = response.status();

... é aqui que recebo 400, "Solicitação incorreta". Minha suspeita inicial é que o ID do pergaminho está errado. Em Python, as solicitações equivalentes de "follow-on" "scroll" funcionam bem.