Output bencode canonico
Codifica byte, interi limitati, liste e dizionari con chiavi byte in bencode canonico ordinato con massimo 65536 byte in uscita.
def bencode(value):
active, visited, used, parts = set(), 0, 0, []
def emit(*chunks):
nonlocal used
size = sum(len(chunk) for chunk in chunks)
if size > 65536 - used:
raise ValueError("bencode.output")
used += size
parts.extend(chunks)
def encode(item, depth):
nonlocal visited
visited += 1
if depth > 16 or visited > 2048:
raise ValueError("bencode.bounds")
if type(item) is int:
if not -10**18 <= item <= 10**18:
raise ValueError("bencode.integer")
emit(b"i", str(item).encode("ascii"), b"e")
elif type(item) is bytes:
if len(item) > 65536:
raise ValueError("bencode.bytes")
emit(str(len(item)).encode("ascii"), b":", item)
elif type(item) in (list, dict):
if id(item) in active or len(item) > 64:
raise ValueError("bencode.container")
active.add(id(item))
try:
emit(b"l" if type(item) is list else b"d")
if type(item) is list:
for child in item:
encode(child, depth+1)
else:
if any(type(k) is not bytes for k in item):
raise ValueError("bencode.key")
for key in sorted(item):
encode(key, depth+1)
encode(item[key], depth+1)
emit(b"e")
finally:
active.remove(id(item))
else:
raise ValueError("bencode.type")
encode(value, 0)
return b"".join(parts)
- Progetto
- Prova contenitori vuoti e annidamento, rifiutando cicli, booleani, interi fuori da ±10^18, oltre 64 voci per contenitore, profondità superiore a 16 o più di 2048 valori visitati.
- Controlla prima di applicare
- Confronta il comportamento effettivo con il risultato atteso. Se una verifica fallisce, indaga la causa prima di altre modifiche.
- Modelli
- Configura un endpoint compatibile con OpenAI o Anthropic usando URL di base e chiave API, se necessaria. Prova la connessione. Il server locale deve essere in esecuzione; gli strumenti remoti possono trasmettere dati separatamente.
def bencode(value):
active, visited, used, parts = set(), 0, 0, []
def emit(*chunks):
nonlocal used
size = sum(len(chunk) for chunk in chunks)
if size > 65536 - used:
raise ValueError("bencode.output")
used += size
parts.extend(chunks)
def encode(item, depth):
nonlocal visited
visited += 1
if depth > 16 or visited > 2048:
raise ValueError("bencode.bounds")
if type(item) is int:
if not -10**18 <= item <= 10**18:
raise ValueError("bencode.integer")
emit(b"i", str(item).encode("ascii"), b"e")
elif type(item) is bytes:
if len(item) > 65536:
raise ValueError("bencode.bytes")
emit(str(len(item)).encode("ascii"), b":", item)
elif type(item) in (list, dict):
if id(item) in active or len(item) > 64:
raise ValueError("bencode.container")
active.add(id(item))
try:
emit(b"l" if type(item) is list else b"d")
if type(item) is list:
for child in item:
encode(child, depth+1)
else:
if any(type(k) is not bytes for k in item):
raise ValueError("bencode.key")
for key in sorted(item):
encode(key, depth+1)
encode(item[key], depth+1)
emit(b"e")
finally:
active.remove(id(item))
else:
raise ValueError("bencode.type")
encode(value, 0)
return b"".join(parts)
Mantieni le modifiche alla serializzazione compatibili e limitate
L'output binario può cambiare significato senza apparire diverso in un normale confronto testuale. Bencora è un ambiente di programmazione con IA per Windows per rivedere il codice di serializzazione tenendo presente questo rischio. Apri il progetto e chiedi al modello collegato di esaminare valori accettati, contratto dell'output e codice utilizzatore prima di suggerire una modifica.
Un'attività concreta può rivedere l'output bencode canonico per un componente che scrive metadati. Chiedi all'assistente di esaminare l'ordine delle chiavi in byte, i contenitori annidati e il rifiuto dei tipi non supportati. Fornisci output di test noti e descrivi i limiti necessari all'applicazione. Mantieni la proposta concentrata su quel componente e i suoi chiamanti, senza presumere che una modifica al serializzatore sia innocua perché produce byte apparentemente validi.
Verifica i limiti delle risorse insieme alle normali conversioni di andata e ritorno. Esegui i tuoi test per profondità massima, output troppo grande e contenitori ciclici, e confronta i byte esatti di dizionari rappresentativi. Esamina i percorsi di ripristino dopo un rifiuto affinché un tentativo fallito non comprometta il lavoro successivo. La compatibilità richiede prove dal codice utilizzatore del progetto oltre a esempi codificati con successo.
Bencora supporta connessioni a endpoint compatibili con OpenAI o Anthropic. Puoi selezionare un modello di IA senza censura dove offerto dal servizio configurato, con strumenti, restrizioni e contesto determinati da quella configurazione. Usa la conversazione per spiegare la modifica, mentre i tuoi casi di test stabiliscono se il contratto dell'output resta intatto.
Rivedere in sicurezza un componente di scrittura binaria
Perché confrontare byte esatti anziché solo valori decodificati?
Valori decodificati equivalenti possono nascondere differenze di ordine o rappresentazione importanti per un formato canonico. Mantieni sequenze di byte note per quei requisiti ed esaminale insieme ai controlli di andata e ritorno già usati dal progetto.
Quale contesto conta per l'ordinamento dei dizionari?
Mostra i tipi effettivi delle chiavi e il codice utilizzatore che dipende dall'output codificato. Chiedi all'assistente di distinguere l'ordine dei byte dall'ordinamento testuale specifico del linguaggio. Una comoda conversione in stringa può alterare un contratto definito sui byte grezzi.
I limiti dell'output vanno controllati solo dopo la codifica?
Rivedi la politica delle risorse necessaria all'applicazione. Un controllo finale della dimensione può avvenire dopo lavoro o allocazioni considerevoli. Chiedi dove la proposta impone i limiti e testa i percorsi di rifiuto, inclusi valori annidati che superano l'output consentito.
Perché includere un caso con contenitore ciclico?
Verifica come il componente gestisce un input che non può essere espanso come un normale albero finito. Verifica rifiuto esplicito e ripristino. Gli esempi di codifica riuscita del modello non dimostrano che le strutture di contenitori malformate terminino correttamente.
Bencora · Aggiornato 2026-10-25