Salut tuturor! 👋

Am vrut să scriu acest articol ca să arăt cum se construiește un pipeline RAG (Retrieval Augmented Generation, adică generare augmentată prin regăsire de informații). Un motiv pentru care ai dori să îl construiești este să activezi căutarea după intenție pentru afacerea sau proiectul tău.

Uneori RAG funcționează cel mai bine împreună cu căutarea lexicală, metoda tradițională de căutare în care se construiește un index inversat, iar rezultatele sunt ordonate cu un algoritm precum BM25+.

Principalul avantaj al RAG este că agenții pot căuta în cantități mari de date după intenție, dar și oamenii pot. Îl poți folosi și fără agenți.

Proiectul

Ca să mă joc cu asta, am vrut să indexez o carte, și am ales Frații Karamazov de Fiodor Dostoievski, iar spre rușinea mea nu am citit-o.

Din fericire, am găsit-o pe Project Gutenberg și putem folosi textul gratuit.

Poți descărca textul de pe site și îl poți salva ca fișier. Am mai făcut și o curățare suplimentară: am șters din date introducerea, încheierea și cuprinsul.

În funcție de modelul folosit pentru generarea embedding-urilor, dacă este un model multilingv, utilizatorii pot pune întrebări despre date în practic orice limbă.

Pașii

Ca să implementăm pipeline-ul RAG vom parcurge următorii pași:

Pe scurt, pașii sunt:

1. Vom genera embedding-urile folosind o bibliotecă Python open source, FlagEmbedding, și un model numit “BAAI/bge-m3”.
2. Vom normaliza vectorii folosind norma L2.
3. Vom reduce dimensiunea de la 1024 la 256. Acesta este un compromis între acuratețe și viteză.
4. Normalizăm din nou.
5. Stocăm embedding-urile finale într-o bază de date vectorială locală: chromadb.

Când interogăm indexul RAG, avem nevoie de același model pentru a genera embedding-ul interogării utilizatorului și de fișierul PCA pentru a reduce dimensiunea embedding-ului generat la 256. Apoi cerem chromadb cei mai apropiați vecini pentru interogarea utilizatorului.

Generarea embedding-urilor

Am folosit Python 3.14 și următoarele dependențe:

uv add FlagEmbeddinguv add scikit-learnuv add chromadb

Următorul fragment de cod Python construiește pipeline-ul descris mai sus.

def main():    paragraphs = load_paragraphs(SOURCE_TEXT)    print(f"Loaded {len(paragraphs)} paragraphs from {SOURCE_TEXT}")    model = BGEM3FlagModel(EMBEDDING_MODEL, normalize_embeddings=False, use_fp16=True)    output = model.encode_corpus(paragraphs, batch_size=32, max_length=MAX_LENGTH)    embeddings = l2_normalize(output["dense_vecs"])    print(f"Embeddings shape: {embeddings.shape}")    pca = PCA(n_components=PCA_COMPONENTS)    embeddings = l2_normalize(pca.fit_transform(embeddings))    norms = np.linalg.norm(embeddings, axis=1)    print(        f"After PCA: shape {embeddings.shape}, "        f"explained variance {pca.explained_variance_ratio_.sum():.1%}, "        f"L2 norms in [{norms.min():.6f}, {norms.max():.6f}]"    )    np.savez(PCA_FILE, mean=pca.mean_, components=pca.components_)    print(f"Saved PCA projection to {PCA_FILE}")    # Reconstruim colecția la fiecare rulare, ca să corespundă mereu cu PCA salvat mai sus.    client = chromadb.PersistentClient(path=str(CHROMA_PATH))    if COLLECTION_NAME in [collection.name for collection in client.list_collections()]:        client.delete_collection(COLLECTION_NAME)    # Vectorii provin de la bge-m3 + PCA, deci Chroma nu trebuie să genereze nimic singură.    collection = client.create_collection(        COLLECTION_NAME, configuration={"hnsw": {"space": "cosine"}}, embedding_function=None    )    batch_size = client.get_max_batch_size()    for start in range(0, len(paragraphs), batch_size):        indices = range(start, min(start + batch_size, len(paragraphs)))        collection.add(            ids=[f"paragraph-{i}" for i in indices],            embeddings=embeddings[indices.start : indices.stop],            documents=paragraphs[indices.start : indices.stop],            metadatas=[{"paragraph": i} for i in indices],        )    print(f"Stored {collection.count()} paragraphs in collection {COLLECTION_NAME!r} at {CHROMA_PATH}")

Rularea codului va scrie toate embedding-urile într-o bază de date vectorială locală, încorporată, chromadb, și va salva fișierul PCA pe disc. Am aplicat PCA asupra embedding-urilor ca să facem un compromis între acuratețe și viteză. Procesarea unui vector de 1024 de elemente necesită mai mult calcul, așa că am aplicat PCA ca să reducem dimensiunea la 256 de elemente.

Interogarea embedding-urilor

Utilizatorul poate interoga embedding-urile printr-un MCP, un API web sau o interfață CLI simplă. Deocamdată folosim varianta CLI, pentru că avem baza de date locală și fișierul PCA, de care avem nevoie ca să construim vectorul de interogare.

def main() -> None:    parser = argparse.ArgumentParser(description="Search The Brothers Karamazov by meaning.")    parser.add_argument("query", help="the text to search for")    parser.add_argument("-k", "--top-k", type=int, default=5, help="number of paragraphs to return")    args = parser.parse_args()    client = chromadb.PersistentClient(path=str(CHROMA_PATH))    try:        collection = client.get_collection(COLLECTION_NAME, embedding_function=None)    except NotFoundError:        raise SystemExit(f"No collection {COLLECTION_NAME!r} in {CHROMA_PATH}; run main.py first")    pca = np.load(PCA_FILE)    model = BGEM3FlagModel(EMBEDDING_MODEL, normalize_embeddings=False, use_fp16=True)    query_vector = embed_query(args.query, model, pca["mean"], pca["components"])    results = collection.query(        query_embeddings=[query_vector],        n_results=args.top_k,        include=["documents", "metadatas", "distances"],    )    hits = zip(results["documents"][0], results["metadatas"][0], results["distances"][0])    for rank, (document, metadata, distance) in enumerate(hits, start=1):        # Colecția folosește distanța cosinus, deci 1 - distanța este similaritatea cosinus.        print(f"\n#{rank}  paragraph {metadata['paragraph']}  score {1 - distance:.3f}")        print(textwrap.fill(document, width=100))

Putem interoga baza de date cu:

uv run src/ragpipeline/query.py "Ivan's poem about the Grand Inquisitor"

Scriptul va crea un embedding pentru interogare, va aplica norma L2, PCA, apoi din nou norma L2, și apoi va interoga chroma db.

Interogarea va returna:

#2  paragraph 1705  score 0.555“My poem is called ‘The Grand Inquisitor’; it’s a ridiculous thing, but I want to tell it to you.”#5  paragraph 5220  score 0.478“My dear fellow, I know a most charming and attractive young Russian gentleman, a young thinker anda great lover of literature and art, the author of a promising poem entitled _The Grand Inquisitor_.I was only thinking of him!”

Exemple de interogări

Iată o altă interogare, de data aceasta în română: „L-au plătit”, adică a fost plătit sau cumpărat.

uv run src/ragpipeline/query.py "L-au platit"#1  paragraph 630  score 0.492“Pay back the three thousand.”#2  paragraph 645  score 0.454“It was he told you about the money, then?”

Am primit câteva rezultate legate de bani, ceea ce este destul de tare. Și ultima interogare, tot în română: „Care sunt partenerele lui Fyodor?”

uv run src/ragpipeline/query.py "Care sunt partenerele lui Fyodor?"#3  paragraph 1  score 0.393He was married twice, and had three sons, the eldest, Dmitri, by his first wife, and two, Ivan andAlexey, by his second. Fyodor Pavlovitch’s first wife, Adelaïda Ivanovna, belonged to a fairly richand distinguished noble family, also landowners in our district, the Miüsovs. How it came to passthat an heiress, who was also a beauty, and moreover one of those vigorous, intelligent girls, socommon in this generation, but sometimes also to be found in the last, could have married such aworthless, puny weakling, as we all called him, I won’t attempt to explain. I knew a young lady ofthe last “romantic” generation who after some years of an enigmatic passion for a gentleman, whomshe might quite easily have married at any moment, invented insuperable obstacles to their union,and ended by throwing herself one stormy night into a rather deep and rapid river from a high bank,almost a precipice, and so perished, entirely to satisfy her own caprice, and to be likeShakespeare’s Ophelia. Indeed, if this precipice, a chosen and favorite spot of hers, had been lesspicturesque, if there had been a prosaic flat bank in its place, most likely the suicide would neverhave taken place. This is a fact, and probably there have been not a few similar instances in thelast two or three generations. Adelaïda Ivanovna Miüsov’s action was similarly, no doubt, an echo ofother people’s ideas, and was due to the irritation caused by lack of mental freedom. She wanted,perhaps, to show her feminine independence, to override class distinctions and the despotism of herfamily. And a pliable imagination persuaded her, we must suppose, for a brief moment, that FyodorPavlovitch, in spite of his parasitic position, was one of the bold and ironical spirits of thatprogressive epoch, though he was, in fact, an ill-natured buffoon and nothing more. What gave themarriage piquancy was that it was preceded by an elopement, and this greatly captivated AdelaïdaIvanovna’s fancy. Fyodor Pavlovitch’s position at the time made him specially eager for any suchenterprise, for he was passionately anxious to make a career in one way or another. To attachhimself to a good family and obtain a dowry was an alluring prospect. As for mutual love it did notexist apparently, either in the bride or in him, in spite of Adelaïda Ivanovna’s beauty. This was,perhaps, a unique case of the kind in the life of Fyodor Pavlovitch, who was always of a voluptuoustemper, and ready to run after any petticoat on the slightest encouragement. She seems to have beenthe only woman who made no particular appeal to his senses.#4  paragraph 676  score 0.389Alyosha rose, but Fyodor Pavlovitch had already changed his mind.

Interogări cu agenți

Și acum ceva diferit. Putem cere agentului să interogheze RAG-ul, iar asta este foarte eficient. Agentul regăsește doar informațiile importante, prin căutare semantică, în loc să citească întreaga carte.

Claude reușește să identifice corect partenerele lui Fyodor.

Concluzie

Construirea unui pipeline RAG este simplă. În era AI poți cere agentului tău să o facă în locul tău, dar poți să îl ghidezi. Biblioteca Python FlagEmbedding conține valori implicite sensibile și tot ce ai nevoie, în spatele unei interfețe simple și ușor de folosit.

Am folosit o bază de date vectorială locală, încorporată, chromadb, pentru acest proiect, dar poți folosi și alte soluții, precum ElasticSearch, care oferă mai multe funcționalități și îți permite să combini RAG cu căutarea tradițională.

Mulțumesc că ai citit!

Codul complet este disponibil pe GitHub și GitLab:

• https://github.com/dnutiu/RagPipeline/blob/main/src/ragpipeline/main.py
• https://gitlab.nuculabs.dev/dnutiu/RagPipeline

Ai deschis vreodată o tabelă numită budget-final-v7-actually-final.xlsx, te-ai uitat la trei aplicații bancare și tot te-ai întrebat unde s-au dus banii? Asta încearcă Fluxa să facă mai puțin frustrant. Este o aplicație de finanțe personale pe care o construiesc pentru lucrurile de zi cu zi: tranzacții, conturi, bugete, obiective și imaginea de ansamblu, dincolo de factura la magazin de luna aceasta.

Iată un tur al părților la care ajung cel mai des. Toate capturile de ecran de mai jos folosesc date fictive, deci cifrele sunt exemple, nu finanțele cuiva.

Începe cu imaginea de ansamblu

Tabloul de bord al Fluxa răspunde mai întâi la întrebările utile: cât a intrat, cât a ieșit, ce a rămas și dacă luna aceasta se comportă cum trebuie. Poți comuta între entitatea curentă, toate entitățile și vederea pe cont, apoi schimba perioada de timp fără să reconstruiești un tabel pivot într-o tabelă.

O prezentare pe șase luni pentru o gospodărie fictivă.

Graficul fluxului de numerar pune împreună veniturile, cheltuielile și mișcarea netă. Defalcările pe categorii și activitatea recentă ajută la explicarea cifrelor. Secțiunea de stare a conturilor adaugă soldurile și o estimare a autonomiei financiare, ceea ce este mult mai util decât un sentiment misterios de „pare în regulă”.

Șase luni de activitate fictivă, cu suficientă variație cât să arate a viață reală și nu a unei tabele copiate.

Dă fiecărui euro (sau leu) o adresă

Poți înregistra venituri și cheltuieli în conturi de numerar, bancare, de card, de economii și de investiții, apoi muta bani între conturi. Fluxa acceptă și mai multe entități, astfel încât finanțele personale și un PFA sau o afacere secundară pot avea propriile tranzacții, apărând totuși într-o vedere combinată.

Tranzacțiile pot fi în RON, EUR, USD, GBP sau CHF. Fluxa folosește cursuri de schimb bazate pe BCE pentru conversie și păstrează moneda și suma originale. Poți alege RON, EUR sau USD ca monedă pentru totalurile generale. Intrările recurente se ocupă de plățile previzibile, iar urmăritorul de abonamente arată cât adună serviciile lunare și anuale și când urmează să fie facturate.

Bugete care îți spun ceva util

Un buget este mai mult decât o listă de cifre optimiste. Fluxa compară alocarea lunară pe fiecare categorie cu cheltuielile reale, arată ce a rămas și estimează încotro se îndreaptă luna. Poți de asemenea să privești de la distanță, în vederea anuală. Aici o mică colecție de abonamente de „doar 49,99” ajunge la momentul adevărului.

Un buget din septembrie populat: alimente, călătorii, cumpărături și restul au cheltuieli reale fictive în dreptul lor.

Obiectivele fac partea cealaltă a planificării mai distractivă. În loc de o promisiune vagă de a economisi pentru o călătorie, îi poți da o țintă, poți rezerva bani dintr-un cont existent sau poți folosi un cont de economii dedicat și poți vedea progresul și data estimată de finalizare. Gospodăria fictivă are în lucru o călătorie în Japonia, un laptop și o renovare a bucătăriei. Se pare că are planuri.

Trei obiective cu bani deja puși deoparte, nu trei bare de progres goale.

Banii sunt mai mult decât soldul contului curent

Averea aduce conturile, investițiile, economiile pentru obiective și bunurile fizice urmărite într-o singură vedere pe entități. Arată soldurile în moneda originală alături de totalurile convertite, plus un istoric și un grafic al alocării. Dacă urmărești o locuință, o bicicletă sau aur și argint fizic, acestea pot intra și ele în tablou. Exemplul de mai jos include un apartament, o bicicletă, un fond indexat și economii.

Un portofoliu fictiv cu fonduri lichide, investiții, bani pentru obiective și bunuri fizice.

Mai puțină tastare, mai multă verificare

Importatorul de extrase bancare Pro poate citi extrase de la BRD, ING, Revolut și UniCredit, inclusiv exporturile CSV de la Revolut. Partea importantă este pasul de verificare: confirmi datele și sumele, ajustezi categoriile sau descrierile, elimini rândurile pe care nu le vrei și abia apoi confirmi importul. Dacă ai confirmat un lot greșit, îl poți anula.

Date ilustrative de verificare a extrasului, inclusiv alimente, transport, servicii și o intrare de venit.

Mai sunt câteva detalii pe care le apreciez: un export Registru Jurnal în PDF și Excel, teme luminoase și întunecate, engleza, româna și germana și o aplicație web instalabilă, care poate pune în coadă venituri sau cheltuieli noi când ești offline și le sincronizează ulterior. Fluxa poate, de asemenea, să împartă o factură comună și să urmărească tranzacțiile recurente, astfel încât treburile mărunte au și ele un loc.

Fluxa este pentru momentul în care vrei un răspuns, nu un alt tab. Dacă ți se pare util, încearcă Fluxa și spune-mi ce parte din tabela ta de bani ai dori cel mai mult să o pensionezi.

Mulțumiri OpenAI Codex pentru ajutorul la redactarea acestui articol, pregătirea datelor demo fictive și realizarea capturilor de ecran.

Salut tuturor! 👋

Acest articol va fi un tur simplu și de bază al modelelor de concurență din Python. Vom începe cu thread-urile, apoi vom trece la procese și, în final, vom acoperi asyncio. Îți voi arăta cum să interacționezi cu aceste mecanisme folosind câteva API-uri de nivel jos, apoi vom trece la API-uri de nivel mai înalt, mai moderne. Îți voi arăta și câteva primitive utilitare pentru sincronizare.

Nu voi acoperi totul, pentru că toate informațiile se găsesc pe site-ul oficial al documentației Python, dar după ce vei citi acest articol vei înțelege bine modelul de concurență din Python.

Thread-uri

Unul dintre modelele principale de concurență sunt thread-urile. Programul tău rulează într-un Process, iar în interiorul procesului există mai multe thread-uri. Deoarece thread-urile rulează în interiorul containerului procesului, ele partajează toate resursele acelui proces.

Thread-urile pot părea că rulează în paralel, în același timp, dar de fapt nu o fac. Python are GIL (Global Interpreter Lock) și, din cauza lui, doar un thread rulează la un moment dat. Totuși, pentru că trec de la unul la altul atât de repede, pare că rulează în paralel.

Pe vremuri, calculatoarele aveau un singur nucleu de CPU, iar sistemul de operare și aplicațiile îl partajau. Codul putea rula doar pe un nucleu, iar pentru ca sistemul de operare să permită multitasking-ul trebuia să aloce fiecărei aplicații o fereastră de timp pe nucleu. Același lucru se întâmplă și astăzi, dar acum avem acces la mai multe nuclee și putem rula lucrurile în paralel.

În alte limbaje, precum Java, thread-urile puteau fi programate pe nuclee diferite, ceea ce le făcea să ruleze în paralel. Dar în Python, din cauza GIL-ului, se permite doar un thread să ruleze în același timp pe fiecare proces.

Thread-urile sunt ușoare în comparație cu procesele, dar sunt costisitoare în comparație cu corutinele.

Deoarece la crearea unui thread trebuie să creezi și resursele partajate, fiecare thread are propria stivă, iar acest lucru nu scalează bine dacă încerci să creezi un milion de thread-uri. Codul sistemului de operare care gestionează thread-urile trebuie, de asemenea, să le programeze, iar dacă există multe thread-uri de programat, se ajunge la un blocaj și performanța scade. Același lucru se întâmplă și cu procesele.

Un fork bomb este un fel de „virus” care se tot bifurcă (fork) la nesfârșit. Sistemul de operare va crea procese până când toate resursele se epuizează, iar acestea nu mai pot fi programate în mod fiabil, ceea ce forțează sistemul să se blocheze.

Thread

Acesta este un exemplu de cod care pornește două thread-uri; ținta este funcția thread_target, care va fi rulată pe cele două thread-uri.

import randomfrom threading import Threadclass Program:    def __init__(self):        self._shared_x = 2    def thread_target(self):        print("Hello from thread")        for i in range(1_000_000):            self._shared_x += random.randint(0, i)    def main(self):        th_one = Thread(target=self.thread_target)        th_two = Thread(target=self.thread_target)        th_one.start()        th_two.start()        th_one.join()        th_two.join()        print("Shared X:", self._shared_x)if __name__ == '__main__':    program = Program()    program.main()

Trebuie să facem join la thread-uri, pentru că dacă nu le facem, thread-ul principal se termină, procesul se oprește, iar celelalte două thread-uri rămân orfane.

Timer

Timer este o clasă utilitară utilă atunci când vrei să programezi o acțiune. Pornește propriul thread și execută acea acțiune. Este util pentru implementarea heartbeat-urilor sau pentru verificarea unor lucruri, cum ar fi reînnoirea tokenurilor de autorizare.

Iată un exemplu simplu de cod pentru afișarea unui heartbeat:

from threading import Timerfrom time import sleepclass Program:    def __init__(self):        self._timer: Timer | None = Timer(5, self.heartbeat)    def heartbeat(self):        print("Heartbeat")        self._timer = Timer(5, self.heartbeat)        self._timer.start()    def run(self):        print("Running the program.")        self._timer.start()        while True:            sleep(1)    def stop(self):        self._timer.cancel()        self._timer = Noneif __name__ == "__main__":    program = Program()    try:        program.run()    except KeyboardInterrupt:        program.stop()

Concurrent Futures: Thread Pool

Acest exemplu este similar cu primul, dar folosește un API de nivel mai înalt pentru programarea thread-urilor.

import randomfrom concurrent.futures import ThreadPoolExecutorclass Program:    def __init__(self):        self._shared_x = 2    def thread_target(self, low):        print("Hello from thread")        for i in range(1_000_000):            self._shared_x += random.randint(min(low, i), i)        return self._shared_x    def main(self):        th_pool = ThreadPoolExecutor(max_workers=5)        th_one = th_pool.submit(self.thread_target, 0)        th_two = th_pool.submit(self.thread_target,2)        print("Shared X after first thread", th_one.result())        print("Shared X after second thread", th_two.result())        print("Shared X:", self._shared_x)if __name__ == '__main__':    program = Program()    program.main()

Se inițializează și un thread pool de dimensiune fixă. Ce returnează pool.submit este un Future. Poți verifica rezultatul future-ului folosind .result(), sau excepția cu .exception().

Documentația conține toate funcțiile detaliate pe care le poți apela pe un obiect Future.

Procese

Procesele sunt gestionate de sistemul de operare și servesc drept container pentru thread-uri. Ele sunt folosite pentru a rula lucruri în paralel. Poți ocoli limitările GIL-ului Python împărțind munca pe mai multe procese, iar dacă munca ta implică multă activitate de I/O sau de rețea, poți porni un loop asincron în fiecare proces.

Crearea mai multor procese este o modalitate excelentă de a aborda o sarcină legată de CPU, iar pentru că sunt gestionate de OS, fiecare proces rulează pe propriul nucleu. Dacă ai mai multe procese decât nuclee disponibile, atunci fiecare proces va primi o fereastră de timp pe nucleul CPU.

Procesele au propria memorie privată, dar API-ul îți permite să partajezi o parte din memorie cu alte procese. Pentru comunicarea între procese poți folosi Queues și Pipes.

Multiprocessing

API-ul multiprocessing este similar cu API-ul threading. Poți porni procese individuale sau poți folosi un pool de procese.

from multiprocessing import Processdef f(name):    print('hello', name)if __name__ == '__main__':    p = Process(target=f, args=('bob',))    p.start()    p.join()

Și un exemplu de pool de procese:

from multiprocessing import Pooldef f(x):    return x*xif __name__ == '__main__':    with Pool(5) as p:        print(p.map(f, [1, 2, 3]))

Exemplele sunt copiate din documentația oficială Python despre multiprocessing, care este o excelentă analiză detaliată a subiectului.

Concurrent Futures: Process Pool

Poți folosi același API concurrent.futures pentru a crea un pool de procese, așa cum ai crea un thread pool. În acest exemplu merită observat că variabila _shared_x nu este de fapt partajată: fiecare proces primește propria copie, iar procesul principal nu o modifică deloc.

import randomfrom concurrent.futures import ProcessPoolExecutorclass Program:    def __init__(self):        self._shared_x = 2    def target(self, low):        print("Hello from process")        for i in range(1_000_000):            self._shared_x += random.randint(min(low, i), i)        return self._shared_x    def main(self):        process_pool = ProcessPoolExecutor(max_workers=5)        th_one = process_pool.submit(self.target, 0)        th_two = process_pool.submit(self.target,2)        print("Shared X after first process", th_one.result())        print("Shared X after second process", th_two.result())        print("Shared X:", self._shared_x)if __name__ == '__main__':    program = Program()    program.main()

Dacă rulezi exemplul, ar trebui să afișeze ceva de genul:

Hello from processHello from processShared X after first process 250199267754Shared X after second process 249818236816Shared X: 2

Asyncio

Asyncio este unul dintre modelele mele preferate de concurență în Python. Când dezvolți servicii web, de obicei vrei să servești mai mulți utilizatori în același timp. Înainte ca acest model să fie folosit, acest lucru se realiza creând un thread sau un proces pentru fiecare cerere. Funcționa bine, dar nu scala bine: există o limită a numărului de procese pe care le putem crea și programa, și același lucru este valabil și pentru thread-uri.

Și hai să fim sinceri: cu API-urile web de astăzi, majoritatea cererilor înseamnă doar preluarea unor date dintr-o bază de date sau cache, un apel de rețea sau calcule numerice. Crearea unui proces nou pentru fiecare cerere ar fi exagerat.

O aplicație construită cu asyncio în minte folosește de obicei un singur proces, iar pe acel proces rulează event loop-ul; în loc de thread-uri, folosim corutine, care sunt similare.

Thread-urile sunt de obicei gestionate de sistemul de operare, ceea ce este mai puțin eficient, iar corutinele sunt gestionate de interpretorul Python. Thread-urile sunt întrerupte de OS pentru a permite rularea altor thread-uri/procese, iar corutinele îți spun exact când pot fi întrerupte, folosind un cuvânt cheie precum await.

Când o corutină cedează voluntar execuția înapoi event loop-ului, event loop-ul alege o altă corutină să ruleze. Este foarte important ca, atunci când folosești acest model, corutina să nu blocheze event loop-ul, nefiind niciodată await-ată pe alte sarcini sau petrecând mult timp cu calcule numerice, pentru că event loop-ul are un singur thread, iar asta înseamnă că celelalte lucruri nu mai vor rula.

Acest model funcționează excelent pentru aplicațiile web, pentru că servesc cererile în paralel, dar dacă scrii un script simplu care face cereri în mod sincron, nu vei câștiga prea mult, de exemplu:

import asyncioasync def task():    await fetch_data()  # wait until finished    await fetch_data()  # then start this    await fetch_data()    await fetch_data()    asyncio.run(task())

Dacă poți, rulează toate cererile în paralel cu asyncio.gather sau cu alternativa mai modernă TaskGroup.

async def fetch_data(n):    print(f"Fetching {n}")    await asyncio.sleep(1)    print(f"Finished {n}")    return nasync def main():    results = await asyncio.gather(        fetch_data(1),        fetch_data(2),        fetch_data(3),        fetch_data(4),    )    print(results)asyncio.run(main())

import asyncioasync def fetch_data(n):    print(f"Fetching {n}")    await asyncio.sleep(1)    print(f"Finished {n}")    return nasync def main():    async with asyncio.TaskGroup() as tg:        task1 = tg.create_task(fetch_data(1))        task2 = tg.create_task(fetch_data(2))        task3 = tg.create_task(fetch_data(3))        task4 = tg.create_task(fetch_data(4))    print(task1.result())    print(task2.result())    print(task3.result())    print(task4.result())asyncio.run(main())

Concluzie

Sper că acest articol ți-a oferit o introducere de bază în modelele de concurență din Python. Nu am acoperit primitivele de sincronizare; de obicei am folosit doar mutex-ul, asyncio.shield și asyncio.Lock. În opinia mea, atunci când scrii aplicații pentru utilizatori și servicii web, este mai bine să păstrezi lucrurile mai simple.

Documentația oficială Python este o resursă excelentă pentru a aprofunda aceste subiecte.

Mulțumesc că ai citit!

Am avut câteva probleme cu Gitlab în ultimele zile, după ce l-am actualizat la 19.3 împreună cu dependențele mele de Alma Linux, push-ul și pull-ul prin SSH au încetat să funcționeze, iar cauza a fost o deriva politicilor SELinux.

Am încercat să rulez gitlab-ctl apply-sepolicy, reconfigurarea și alte comenzi, dar nimic nu părea să funcționeze. Mi-a luat ceva timp să găsesc cauza de bază a problemei. Inițial am crezut că clientul meu SSH din Fedora este defect, și folosesc și 1Password pentru a gestiona cheile SSH. Ei bine, nu asta era problema: ssh -vvv git@git.nuculabs.dev este foarte detaliat și m-a ajutat la depanare, problema era pe server.

Cel mai bun mod de a rezolva politicile SELinux este să folosești comanda audit2allow. De fiecare dată când SELinux refuză o acțiune, daemonul o înregistrează în jurnal, iar utilitarul de mai sus te poate ajuta să generezi reguli care pot fi adăugate în SELinux.

După ce am rulat de mai multe ori următoarele comenzi, am obținut toate regulile lipsă.

sudo ausearch -m AVC -ts recent \  | audit2allowsudo ausearch -m AVC -ts recent \  | audit2allow

Dacă ai aceleași probleme, nu trebuie să rulezi audit2allow, am salvat fișierul .te, pe care îl poți compila și împacheta pentru a-l instala ca modul SELinux.

Salvează următorul conținut ca „gitlab_ssh.te”

module gitlab_ssh 1.0;require {        type sshd_session_t;        type gitlab_shell_t;        class file { getattr open read };        class dir { getattr search };}#============= sshd_session_t ==============#!!!! Acest avc este permis în politica actualăallow sshd_session_t gitlab_shell_t:dir search;allow sshd_session_t gitlab_shell_t:dir getattr;#!!!! Acest avc este permis în politica actualăallow sshd_session_t gitlab_shell_t:file { getattr open read };

Pentru a-l instala, execută următoarele comenzi:

➜  ~ checkmodule -M -m -o gitlab_ssh.mod gitlab_ssh.te➜  ~ semodule_package -o gitlab_ssh.pp -m gitlab_ssh.mod➜  ~ sudo semodule -i gitlab_ssh.pp

Gata! Sper că ți-am economisit ceva timp de depanare.

Recent m-am inspirat de Omarchy ca să creez un script pentru nevoile mele, și anume să automatizez configurarea mea de Fedora. Ideea este similară cu omakase sushi, care înseamnă „las pe seama ta”: în loc să comanzi piesă cu piesă, bucătarul de sushi știe cel mai bine ce și cum să servească.

Am creat acest script cu codex și l-am publicat pe conturile mele de Gitlab și Github:

• https://gitlab.nuculabs.dev/dnutiu/FedoraLaunch
• https://github.com/dnutiu/FedoraLaunch

Scriptul este adaptat gusturilor mele și configurează următoarele:

Mediul de dezvoltare:

• Python, uv și pyenv
• Ruby și rbenv
• NodeJS și nvm
• Go
• Rust
• Java și sdkman
• Docker
• Helm

De asemenea, configurează shell-ul să folosească zsh și instalează oh-my-zsh.

Aplicații software precum:

• PrusaSlicer pentru imprimare 3D
• Software CAD: KiCAD, FreeCAD
• Snap
• Obsidian
• 1Password
• Codex
• Hey Mail
• VLC
• qBittorrent
• Steam
• Zed
• VSCode
• IntelliJ

În rest, încearcă să detecteze ce drivere trebuie instalate pentru sistem, le instalează împreună cu codecurile suplimentare și activează accelerarea hardware. De asemenea, pregătește structura de directoare pentru montarea NAS-ului meu.

Atât! Înainte de acest script, trebuia să petrec câteva ore ca să instalez și să caut tot acest software ca să-mi configurez sistemul pe placul meu, iar acum durează doar câteva minute.

Mulțumesc că ai citit!

M-am abonat la OpenCode[1] săptămâna trecută doar ca să încerc GLM 5.2 și, până acum, sunt destul de impresionat de el. Folosesc zilnic Claude Opus 4.8 și am folosit din când în când și DeepSeek V4 Pro și Kimi K2.6.

În general, GLM a fost mai bun decât Kimi la design. Am schimbat complet tema blogului meu, de la aspectul implicit al Jekyll Minimal Mistakes la o temă cu pixel art inspirată din Terraria.

Kimi a creat tema inițială, care era interesantă și era ceea ce urmăream atunci, apoi GLM a făcut-o și mai bună. A înlocuit fundalul CSS cu o adevărată dală de plăci, a scris un script Python care a generat dala în pixel art și apoi a setat-o ca fundal pentru blog.

Apoi a adăugat tot felul de lucruri amuzante: un subsol reproiectat, particule de lavă, realizări, un antet animat cu copaci și nori și a făcut antetul să știe dacă e zi sau noapte, anotimpul iarnă și alte lucruri, și zombi! În total, e destul de tare. Am încercat și efecte interesante cu Kimi, dar nu au nimerit tocmai.

L-am folosit și ca să generez două SDK-uri pentru facturare, pentru software-ul meu de facturare SmartBill[2].

Unul este SDK-ul în Ruby[3], iar celălalt este în Python[4].

Ca să generez clienții, i-am dat modelului specificația swagger și i-am spus să genereze clienții. Apoi l-am ghidat ca codul să urmeze cele mai bune practici, să fie structurat corect și să folosească biblioteci moderne pentru cereri și validarea modelelor.

Testul final a fost să-i spun modelului să adauge în repository abilități pentru agenți, apoi să folosească aceste abilități ca să creeze o ciornă de factură pe platformă. Și a funcționat.

Să poți spune unui agent: „Creează o factură pentru X” și apoi să ai factura gata este destul de tare, cel puțin în opinia mea.

Am instalat și agentul Hermes[5] în weekendul acesta și m-am jucat puțin cu el. Nu am făcut nimic complicat, doar un commit în git, vorbind cu el prin iMessage. Îmi pot imagina o lume în care adăugăm astfel de abilități agenților și atingem obiective prin mesaje text sau vorbind cu agentul.

Totuși, acum nu rulez agentul. Cred că e periculos să-i dai permisiune și acces la lucrurile mele, iar costurile abonamentului descurajează: dacă vrei voce, trebuie să plătești. Dacă vrei căutare, trebuie să plătești. Dacă vrei analiză de imagini, trebuie să plătești. Trebuie să plătești și pentru model. Deci mă aștept să plătesc și ca să-i scriu în viitor, pe când acum iMessage e gratuit.

Îmi plac lucrurile simple, iar mie configurația asta „agentică” mi se pare prea complicată și fragilă. Pentru moment voi crea facturile manual și mă bucur că nu trebuie să plătesc 5 abonamente diferite, dar a fost un experiment distractiv.

[1] - https://opencode.ai/go

[2] - https://www.smartbill.ro

[3] - https://github.com/dnutiu/SmartBill-Ruby-SDK

[4] - https://github.com/dnutiu/SmartBill-Python-SDK

[5] - https://hermes-agent.nousresearch.com/

Au trecut ceva vreme de când nu am mai recenzat o tastatură pe acest blog. Ultima mea recenzie a fost pentru tastatura Logitech MX Keys, iar de atunci am schimbat două tastaturi, iar am ajuns la ZSA Moonlander, la recomandarea cuiva mai experimentat cu tastaturile.

Tastatura Logitech s-a stricat după 2 ani, așa că m-am gândit să iau tot o tastatură cu membrane. Am luat un Keychron B1 Pro, care avea un preț bun, cam 50$. A fost în regulă un timp, dar nu are taste luminate și nici picioruște reglabile. A trebuit să printez 3D niște picioruște pe care le-am lipit apoi de ea. Per total, o tastatură decentă pentru preț.

După aceea am vrut să încerc o tastatură mecanică și am cumpărat un Numphy Air V2 75% cu switch-uri brown. Nu mi-a plăcut această tastatură. A trebuit să fac o actualizare de firmware ca să o pot configura din software, iar nu m-am putut obișnui cu layout-ul, era ciudat. Carcasa tastaturii părea totuși solidă. Am returnat tastatura, iar vânzătorul nu a mai așteptat-o, mi-a dat banii înapoi integral, ceea ce mi s-a părut puțin ciudat, pentru că nu mă așteptam la asta. Până la urmă am vândut tastatura cuiva cu aproximativ 100$.

Apoi am luat un Keychron K5 Max, cam cu 100$, cu switch-uri red. Speram ca switch-urile red să fie silențioase, dar nu sunt chiar silențioase, nici foarte zgomotoase. Tastatura este excelentă, am păstrat-o și am dat-o soției mele. Singurul dezavantaj este că keycap-urile nu sunt transparente, iar când e întuneric nu se vede direct litera luminată.

Acum am tastatura mea split Moonlander cu switch-uri cherry mx red silent de cam 3 săptămâni. A fost destul de scumpă, iar când am primit-o, la început am crezut că am greșit, pentru că layout-ul este diferit și nu puteam scrie niciun cuvânt pe ea.

Pe măsură ce am folosit-o tot mai mult, am început să o îndrăgesc și am fost cu adevărat impresionat de software și de opțiunile de configurare.

Poți asocia fiecărei taste orice vrei și poți personaliza și RGB-ul, ca să le colorezi după cum dorești. Keycap-urile sunt transparente, iar noaptea se vede litera luminată.

O altă surpriză sunt switch-urile. Cherry mx red silent sunt de fapt silențioase comparativ cu ce aveam înainte, nu au sunet clicky, iar uneori par chiar mai silențioase decât tastatura cu membrane a laptopului meu.

Configuratorul este bazat pe web și ușor de folosit. L-am folosit pe Windows, Linux și macOS. Pe Linux trebuie să adaugi niște reguli udev ca să poți flasha firmware-ul și configurația pe tastatură, iar software-ul te ghidează și îți oferă regulile.

Nu poți flasha firmware-ul pe tastatură fără să apeși butonul de flash cu un știft, ceea ce înseamnă că este destul de greu, dacă nu chiar imposibil, să flashezi firmware-ul dacă nu ai la dispoziție un ac sau un știft subțire.

În ceea ce privește configurarea, poți face următoarele:

• Să asociezi fiecare tastă cu ce vrei când este apăsată scurt.
• Să schimbi comportamentul tastei când este apăsată de două ori.
• Să schimbi comportamentul tastei când este apăsată scurt și ținută. (Nu sunt sigur cum funcționează)
• Să schimbi comportamentul tastei când este ținută apăsată.
• Să atribui o culoare RGB fiecărei taste în parte.
• Să atribui acțiuni personalizate tastelor, precum: schimbare de layer, combinații, animații, acțiuni de mouse.
• Să creezi combinații de taste, de exemplu: A + S = o tastă personalizată, ca ESC sau Print Screen
• Să atribui macro-uri tastelor, de exemplu: când apeși o tastă se trimite Alt+F4

Opțiunile de configurare sunt uimitoare, dar asta înseamnă și că nimeni nu va putea folosi tastatura ta dacă ai o configurație personalizată, pentru că trebuie să îți amintești tastele sau să te bazezi pe memoria musculară.

Următoarea funcție excelentă a tastaturii sunt layer-ele. Momentan am 3 layere configurate.

• Primul layer este pentru scris.
• Al doilea layer este pentru simboluri, pentru programare, și ca un numpad personalizat.
• Al treilea layer este pentru controalele multimedia și pentru animațiile RGB ale tastaturii.

Layer-ele sunt foarte tari. Odată ce te obișnuiești cu ele, extind enorm ceea ce poți face cu tastatura:

Cea mai bună funcție a tastaturii este confortul pe care îl oferă mâinilor și posturii tale. Am cumpărat-o în principal pentru că simțeam durere în mâini, iar am început să folosesc mănuși de compresie și un mouse vertical. Acestea m-au ajutat într-o oarecare măsură, dar durerea mi-a dispărut după o săptămână cu tastatura.

Pe măsură ce folosesc tastatura, mă obișnuiesc tot mai mult cu ea, iar dacă în prima săptămână scriam 11 cuvinte pe minut, comparativ cu 90 acum, este și mai bine.

Asta e tot, sper că ți-a plăcut recenzia mea și îți mulțumesc că ai citit! 📚

Acesta este un scurt articol despre conectarea Nintendo Switch 2 Pro Controller la un calculator cu Linux.

Folosesc controllerul pe computerul meu personal ca să joc jocuri pe Steam. Steam suportă controllerul, iar pentru ca el să fie recunoscut trebuie doar să adaugi câteva reguli noi pentru udev și să le reîncarci.

Pentru asta, creează următorul fișier cu nano:

sudo nano /etc/udev/rules.d/50-nintendo-switch.rules

Apoi lipește în el conținutul regulilor udev:

SUBSYSTEM=="usb", ATTR{idVendor}=="057e", ATTR{idProduct}=="2066", MODE="0666"SUBSYSTEM=="usb", ATTR{idVendor}=="057e", ATTR{idProduct}=="2067", MODE="0666"SUBSYSTEM=="usb", ATTR{idVendor}=="057e", ATTR{idProduct}=="2069", MODE="0666"SUBSYSTEM=="usb", ATTR{idVendor}=="057e", ATTR{idProduct}=="2073", MODE="0666"SUBSYSTEM=="hidraw", ATTRS{idVendor}=="057e", ATTRS{idProduct}=="2066", MODE="0666"SUBSYSTEM=="hidraw", ATTRS{idVendor}=="057e", ATTRS{idProduct}=="2067", MODE="0666"SUBSYSTEM=="hidraw", ATTRS{idVendor}=="057e", ATTRS{idProduct}=="2069", MODE="0666"SUBSYSTEM=="hidraw", ATTRS{idVendor}=="057e", ATTRS{idProduct}=="2073", MODE="0666"

Apoi rulează:

sudo udevadm control --reload-rules

Gata! Ar trebui să vezi controllerul în Steam când este conectat prin cablul USB, Bluetooth-ul nu funcționează încă.

Mulțumesc că ai citit!

Acest articol este despre arborii Huffman. Am făcut acest proiect la facultate și, după vreo zece ani, am vrut să-l reiau ca să-mi consolidez înțelegerea și să exersez codificarea manuală.

Introducere

Arborele de codificare Huffman este o structură de date fundamentală în informatică și este folosit pentru compresia fără pierderi a datelor și pentru codificarea entropică. Arborii de codificare Huffman sunt deja folosiți în ZIP, Mp3, Png pentru compresie, adesea nu singuri, ci împreună cu alți algoritmi de compresie a datelor.

Entropia reprezintă aleatorietatea datelor.

Să luăm roooar: are 6 caractere și 3 caractere unice, iar entropia este scăzută din cauza caracterelor care se repetă, ceea ce implică mai puțină incertitudine. Pentru 123456, sunt 6 caractere și 6 caractere unice, entropia este ridicată pentru că datele arată ca fiind „aleatorii”, există mai multă incertitudine.

Codificarea entropică urmărește să codifice datele cu entropie scăzută astfel încât să poată fi comprimate mai eficient. Pentru roooar ai nevoie de 6 octeți de date, dar atribuind coduri poți folosi mai puțini octeți. De exemplu, poți atribui următorii biți literelor:

Rezultatul va fi ceva de genul: 100,0,0,0,101,100, care reprezintă cuvântul roar folosind doar 12 biți, ceea ce înseamnă că ai comprimat cuvântul roooar de la 6 octeți la 2 octeți. Va trebui să completezi cei 12 biți până ajungi la 16 biți, adică doi octeți.

Dacă vrei să implementezi singur arborii Huffman, derulează până la secțiunea Referințe și consultă linkurile. În continuare îți voi arăta și discuta implementarea mea în Python.

Implementarea unui instrument de compresie

Să parcurgem un instrument în Python care comprimă datele folosind arborii de codificare Huffman. Implementarea completă poate fi găsită în conturile mele de Github și de GitLab self-hosted.

• https://github.com/dnutiu/huffman-trees
• https://gitlab.nuculabs.dev/dnutiu/huffmantrees

Harta frecvențelor

Primul pas este crearea unei hărți a frecvențelor: trebuie să numeri caracterele din fișierul sursă ca să determini caracterele și octeții care apar cel mai des.

În Python, poți crea o hartă a frecvențelor parcurgând octeții fișierului și numărând de câte ori apare fiecare octet.

    def _build_frequency_map(self, content: bytes) -> dict[int, int]:        """            Construiește harta frecvențelor numărând de câte ori apare fiecare octet în conținut.        :param content: Octeții conținutului sursă.        :return: Un dicționar reprezentând harta frecvențelor.        """        with utils.Timer(name="Build frequency map", logger=self._logger):            frequency_map = defaultdict(lambda: 0)            for byte in content:                frequency_map[byte] += 1            return frequency_map

Cred că această parte este destul de simplu de înțeles. Următorul pas este să folosim harta frecvențelor pentru a construi arborele.

Construirea arborelui

Arborele Huffman are două tipuri de noduri: noduri interne și noduri frunză. Pe noi ne interesează deocamdată doar nodurile frunză, iar nodurile interne le folosim ca să parcurgem arborele și să obținem codificarea finală.

Strategia este să creăm un nod frunză pentru fiecare octet și să-i atribuim o pondere egală cu frecvența sa. Apoi luăm două elemente (noduri frunză sau interne) cu ponderea cea mai mică și construim un nod intern, căruia îi atribuim ca pondere suma celor două noduri luate.

Ca să facem asta eficient, putem folosi un min heap sau o coadă de priorități minimă. Dacă vrei să rămâi simplu, poți pune toate nodurile frunză într-un array și să creezi o funcție care returnează și elimină elementul cu ponderea minimă. Folosești această funcție recursiv ca să iei câte două elemente deodată, construiești un nod intern și pui înapoi nodul intern în array. Repetând asta de multe ori, vei ajunge cu un singur element în array, care este nodul rădăcină.

În implementarea mea am folosit un min heap ca să găsesc eficient elementul minim și să construiesc arborele.

În fragmentul următor am inclus întregul cod sursă al arborelui:

import abcimport heapqimport typingfrom functools import total_orderingclass BaseTreeNode(abc.ABC):    """    Clasă abstractă de bază care modelează un arbore Huffman.    """    def __init__(self, weight: int, is_leaf: bool = False):        self._weight: int = weight        self._is_leaf: bool = is_leaf    def weight(self) -> int:        return self._weight    def is_leaf(self) -> bool:        return self._is_leaf@total_orderingclass LeafNode(BaseTreeNode):    def __init__(self, byte_element: int, weight: int):        super().__init__(weight, is_leaf=True)        self._element: int = byte_element    def value(self) -> int:        return self._element    def __lt__(self, other):        if not issubclass(other.__class__, BaseTreeNode):            return NotImplemented        return self.weight() < other.weight()class InternalNode(BaseTreeNode):    def __init__(self, left: BaseTreeNode, right: BaseTreeNode):        weight = left.weight() + right.weight()        super().__init__(weight, is_leaf=False)        self._weight = weight        self._left = left        self._right = right    def left(self):        return self._left    def right(self):        return self._right    def __lt__(self, other):        if not issubclass(other.__class__, BaseTreeNode):            return NotImplemented        return self.weight() < other.weight()    @staticmethod    def from_frequency_map(        frequency_map: dict[int, int],    ) -> typing.Optional["InternalNode"]:        """            Construiește arborele Huffman dintr-o hartă a frecvențelor dată.        :param frequency_map: Harta frecvențelor.        :return: Un nod intern reprezentând rădăcina arborelui.        """        if not frequency_map:            return None        # Creează un heap        binary_heap = []        for item in frequency_map.items():            # adaugă elementul în heap după frecvență și caracter            heapq.heappush(binary_heap, LeafNode(byte_element=item[0], weight=item[1]))        # Construiește arborele Huffman        while len(binary_heap) > 1:            left = heapq.heappop(binary_heap)            right = heapq.heappop(binary_heap)            #  nod intern după frecvență, pentru a putea fi parcurs            heapq.heappush(binary_heap, InternalNode(left, right))        return binary_heap[0]

Crearea codificărilor

Trebuie să parcurgi arborele ca să construiești tabelul de codificare sau ca să obții codificarea pentru un singur caracter. Ca să evit munca duplicată, am decis să parcurg arborele o singură dată și să construiesc tabelul de codificare dintr-o dată.

Pentru a parcurge arborele poți folosi algoritmul DFS (Depth First Search, parcurgere în adâncime). Funcționează mergând în adâncime până la fiecare nod frunză. Odată ajuns la un nod frunză, salvezi valoarea într-o hartă, împreună cu drumul parcurs ca să ajungi acolo: dacă ai mers la stânga, de obicei pui un 0, iar dacă ai mers la dreapta, poți pune un 1.

    def _build_encoding_table(self):        """        Construiește tabelul de codificare pentru Huffman folosind un algoritm DFS pe arbore.        """        with utils.Timer(name="Build encoding table", logger=self._logger):            stack = []            root = self._huffman_tree_root            stack.append([root, []])            while len(stack) > 0:                element, encoding = stack.pop()                if element.is_leaf():                    self._encoding_table[element.value()] = "".join(encoding)                else:                    if (left := element.left()) is not None:                        stack.append([left, [*encoding, "0"]])                    if (right := element.right()) is not None:                        stack.append([right, [*encoding, "1"]])

Scrierea în fișier

Scrierea în fișier este partea delicată, pentru că, după ce codifici fiecare element într-o secvență de biți, trebuie să completezi numărul final de biți astfel încât să fie divizibil cu 8, iar tu poți scrie doar 8 biți (un octet) la un moment dat. Nu poți scrie, de exemplu, 111; trebuie să scrii un octet întreg cu completare, adică 11100000. Am folosit pachetul Python bitstring ca să simplific acest proces, iar la final am adăugat completarea manual.

Pe lângă conținut, trebuie să scrii în fișier și tabelul de codificare. Acesta va fi folosit pentru decodificarea fișierului. Pentru a scrie tabelul de codificare am folosit pachetul din biblioteca standard Python pickle, dar poți folosi și o bibliotecă terță, cum ar fi msgpack, ca să convertești obiectul în formă binară. Îl poți scrie și ca un simplu șir de caractere.

Am scris tabelul de codificare la început, împreună cu lungimea sa, ca să știu că restul octeților reprezintă conținutul fișierului.

    def _get_encoded_file_contents(self, content: bytes) -> BitArray:        """            Având conținutul necodificat, îl codifică cu codurile Huffman.        :param content: Octeții conținutului brut.        :return: Octeții conținutului codificat.        """        with utils.Timer(name="Encode source file", logger=self._logger):            buffer = []            for byte in content:                buffer.append(self._encode_byte(byte))            bit_array = BitArray(bin="".join(buffer))            return bit_array    def _encode_byte(self, byte: int) -> str:        """        Codifică octetul dat folosind arborele Huffman.        """        if byte in self._encoding_table:            return self._encoding_table[byte]        raise Exception(            f"Can't encode byte {byte}. It is not found in the encoding table."        )    def encode(self, file_name: str, destination: str):        """            Codifică un fișier dat în octeți Huffman și îl scrie pe disc..        :param file_name: Calea către numele fișierului.        :param destination: Calea către numele fișierului de destinație.        """        with open(file_name, "rb") as fh:            content = fh.read()        frequency_map = self._build_frequency_map(content)        self._build_huffman_tree(frequency_map)        self._build_encoding_table()        bit_array = BitArray()        encoding_table = pickle.dumps(self._encoding_table)        # întreg fără semn de 2 octeți pentru lungimea tabelului de codificare        bit_array.append(pack("<H", len(encoding_table)))        # tabelul de codificare complet, serializat cu pickle        bit_array.append(encoding_table)        # conținutul fișierului codificat cu Huffman        encoded_content = self._get_encoded_file_contents(content)        if len(encoded_content) % 8 == 0:            encoded_content_padding_bits = 0        else:            encoded_content_padding_bits = 8 - (len(encoded_content) % 8)        bit_array.append(pack("<B", encoded_content_padding_bits))        bit_array.append(encoded_content)        self._write_to_destination_file(bit_array, destination)        self._logger.info(f"Done encoding {file_name}.")#...    def _write_to_destination_file(self, content: BitArray, destination: str):        """            Scrie octeții în fișierul de destinație.        :param content: Octeții conținutului.        :param destination: Numele fișierului de destinație.        """        with utils.Timer(name="Write to destination", logger=self._logger):            with open(destination, "wb") as fh:                content.tofile(fh)            self._logger.debug(                f"Wrote {content.len} bits to destination file: {destination}"            )

Decompresia

Decompresia fișierului este un pas simplu. Poți citi tabelul de codificare, îl poți inversa, construi o hartă și poți recupera elementele originale de acolo, apoi poți scrie octeții în fișierul de ieșire.

Concluzie

Proiectul Huffman este unul interesant: atinge algoritmi, manipulări de biți, fișiere, I/O și este folosit în multe aplicații reale, precum și în formate. Dacă încerci să comprimi un PNG cu el, nu va funcționa, pentru că comprimarea de două ori nu aduce rezultate mai bune.

Dacă vrei să-l implementezi singur, încearcă. Mai jos găsești implementarea mea în Python și câteva referințe pe care le-am folosit ca să o scriu.

Mulțumesc pentru lectură!

Referințe

• https://en.wikipedia.org/wiki/Entropy_(computing)
• https://en.wikipedia.org/wiki/Entropy_coding
• https://codingchallenges.fyi/challenges/challenge-huffman/
• https://opendsa-server.cs.vt.edu/ODSA/Books/CS3/html/Huffman.html
• https://gitlab.nuculabs.dev/dnutiu/huffmantreespy/
• https://github.com/dnutiu/huffman-trees

Am vrut să scriu câteva gânduri despre tot subiectul mediilor fizice.

După ce Sony a anunțat că va înceta lansarea jocurilor fizice pentru PlayStation după ianuarie 2027, nu mi-am dat seama cât de mult îmi doresc medii fizice.

Anul trecut am cumpărat multe DVD-uri și câteva BlueRay-uri cu unele dintre filmele mele preferate, precum și CD-uri audio. DVD-urile nu arată foarte bine pe ecranele de azi, dar BlueRay-urile merg perfect. Cred că e necesar să încercăm să păstrăm formatul fizic, cel puțin pentru filme și audio. Companiile pot oricând să scoată filme din biblioteca lor și din a ta, mai mult decât atât, le pot cenzura, șterge anumite capitole sau scene, și asta pentru că nu ții în proprietate datele, le închiriezi, ah, scuze, ai o „licență” de utilizare.

CD-urile audio pe care le-am cumpărat ar putea fi ușor extrase și muzica transferată în biblioteca mea de muzică din cloud, self-hosted, ca s-o pot asculta oricând și să am control total asupra datelor.

Mi-ar plăcea personal să dețin datele și dispozitivele mele, acesta este unul dintre principalele motive pentru care folosesc Linux.

Pentru jocuri însă povestea este puțin diferită. Platforma PlayStation este proprietară, ceea ce înseamnă că discurile tale rulează pe software-ul ei, iar o actualizare online poate oricând să facă dispozitivul să refuze să le redea sau să forțeze modificarea fișierelor jocului, pentru cenzură sau eliminarea conținutului din motive de licențiere.

Jocurile fizice sunt totuși excelente, le poți împrumuta prietenilor sau le poți revinde dacă nu-ți plac, iar consolele Sony și Nintendo au reguli de rambursare foarte stricte: dacă cumperi un joc și îl descarci, nu poți cere rambursarea. Steam, pe PC, în schimb, este un paradis al serviciilor pentru clienți. Cred că poți juca jocul cel mult 2 ore și, dacă nu au trecut 14 zile, poți cere o rambursare și îți returnează integral suma.

Cred că avantajul de a avea un PS în loc de PC este destul de mic în zilele noastre. Cu PlayStation poți juca la televizor și ai un sistem de joc gata de utilizare, și asta e în regulă, dar cu PC-ul poți face atâtea alte lucruri, iar dacă investești într-un PC bun, va dura ani de zile, iar piesele pot fi upgradate dacă vrei. PC-ul meu are acum 5 ani și m-am gândit să-l upgradez cu un procesor mai bun și o placă video mai bună, dar nu există niciun motiv, funcționează și rulează jocurile bine, upgradarea ar fi o risipă de bani fără rost. Am 64GB RAM, pe care abia îl folosesc oricum.

Îmi place enorm Nintendo Switch 2, pot juca la televizor, în mișcare, iar jocul meu preferat în momentul de față este Resident Evil Requiem, și sunt bucuros că au decis să rămână la mediile fizice. Sper ca lucrurile să nu se schimbe.

Mulțumesc pentru lectură!