IT pomocník

Pozor! Nutno aplikovat na stereo stopu, kde jsou dvě identické stopy

Nejprve Modulace hlasu - Efekt: Tremolo 40% per 40 Hz

Potom Modulace hlasu - Efekt: Vocoder - vzdálenost 2, 40 bands + jehly

Audacity je na tyhle věci nejpohodlnější.

Kde najdeš efekt Vocoder

Otevři Audacity.
Nahraj nebo otevři zvukový soubor.
Označ část stopy (nebo celou stopu).
V horním menu klikni na:
Efekty → Vocal Modulation / Distortion → Vocoder
(v češtině podle překladu: Efekty → Zkreslení hlasu → Vocoder – záleží na jazykové mutaci Audacity).

Pokud používáš novější verzi Audacity (3.x a vyšší), efekty jsou seřazené abecedně v nabídce Efekty. Tam najdeš Vocoder rovnou.

Jak funguje Vocoder

Kombinuje tvoji hlasovou stopu s tzv. carrier wave (nosičem, typicky sinusový tón nebo šum).
Výsledkem je „robotický“ nebo „anonymizovaný“ hlas, hodně podobný tomu, co se používalo v TV pořadech devadesátých let.
Můžeš si nastavit počet pásem (Bands), frekvenci nosiče, úroveň šumu atd. → čím víc pásem, tím srozumitelnější řeč; čím méně, tím „cizejší“.

🔧 Doporučené nastavení Vocoderu v Audacity

📋 Vysvětlení jednotlivých voleb:

Vzdálenost → určuje, jak moc bude hlas „rozmazán“ (něco jako časový krok).
Počet pásem → kolik frekvenčních pásem se použije pro modulaci (víc pásem = čitelnější, míň pásem = anonymnější a robotické).
Rozkmit původního zvuku v procentech → kolik procent původní stopy má zůstat slyšet (dej to hodně nízko, třeba 10–20 %, aby se hlas ztratil).
Rozkmit bílého šumu v procentech → kolik bude přimícháno bílého šumu (vyšší hodnota = větší anonymizace).
Rozkmit jehel radaru v procentech → přidává zvláštní syntetický „pípavý“ podklad, obvykle se nepoužívá, pokud nechceš sci-fi efekt.
Kmitočet jehel radaru v Hz → určuje, jak rychle budou ty „jehly“ pulzovat.

🔧 Doporučené nastavení pro anonymizaci hlasu (styl „TV pořad 90. let“)

Vzdálenost: 30–40
Počet pásem: 20–25
Rozkmit původního zvuku: 10–20 %
Rozkmit bílého šumu: 70–80 %
Rozkmit jehel radaru: 0 % (nech vypnuté, pokud nechceš sci-fi efekt)
Kmitočet jehel radaru: libovolné, ale při 0 % stejně nemá vliv

🎧 Tip na vylepšení

Pokud chceš ještě lepší „anonymizační“ efekt:

Nejprve použij Efekt → Změna výšky tónu a sniž hlas o 3–5 půltónů.
Pak aplikuj Vocoder s výše uvedenými parametry.

To dá velmi podobný výsledek, jaký se používal v pořadech typu Tabu.

* * *

Požadujou stopu sterea, jak mám v novém souboru přidat stopu R?

efekt Vocoder v Audacity opravdu vyžaduje stereo stopu (jedna stopa je „modulátor“ = hlas, druhá je „carrier“ = šum nebo jiný signál). Pokud máš jen mono nahrávku, musíš přidat druhý kanál.

🛠 Postup, jak přidat druhou stopu (pravý kanál)

V menu nahoře klikni:
Stopy → Přidat novou → Stereofonní stopa
(nebo Stopy → Přidat novou → Mono stopa, pokud chceš pracovat jen s pravým kanálem a pak to převést).
Do té nové stopy vlož bílý šum:
- Generovat → Šum… → Typ: Bílý
- nastav délku šumu stejně dlouhou jako tvoje nahrávka hlasu.
Teď máš dvě stopy: hlas (modulátor) a šum (carrier).
Vyber obě stopy současně (myší nebo Ctrl+A na timeline).
Aplikuj efekt Vocoder → teď už by neměl hlásit chybu o stereo.

🎧 Tip

Pokud máš původní hlasovou nahrávku už jako stereo, ale se stejným signálem v L/R, tak:

Rozděl stereo stopu na mono:
Stopy → Rozdělit stereo na mono
Do jedné stopy necháš hlas, do druhé vložíš šum.

Jak mám vybral levý kanál?

🔹 Jak vybrat levý kanál stereo stopy

Najdi vlevo panel u stopy (s názvem, tlačítky Mute/Solo, posuvníky).
Klikni na malý šipečkový rozbalovací menu (u názvu stopy).
V nabídce vyber:
Rozdělit stereo stopu na mono.

Tím se jedna stereo stopa rozdělí na dvě samostatné mono stopy:

Horní = levý kanál (L)
Dolní = pravý kanál (R)

Teď už můžeš kliknout přímo do levé stopy → tím ji označíš a pracuješ jen s ní.

🎧 Tipy navíc

Pokud chceš pouze levý kanál a pravý nepotřebuješ → pravou stopu můžeš hned zavřít kliknutím na X vlevo.
Pokud chceš oba kanály znovu spojit → použij Stopy → Udělat stereo stopu.

Jak vypnout přehrávání zvuku jedné stopy? Mám ji už vybranou

V Audacity můžeš dočasně ztlumit přehrávání jedné stopy bez smazání nebo změny zvuku:

1️⃣ Použití tlačítka Mute

Na levé straně stopy (v panelu s názvem stopy) je tlačítko Mute.
Kliknutím na Mute se tato stopa během přehrávání neuslyší.
Stopa zůstává ve projektu, jen se přestane přehrávat.

2️⃣ Použití posuvníku Gain

Vedle tlačítka Mute je Gain posuvník.
Posunutím úplně doleva stoupí hlasitost na –∞ dB, což efektivně stopu ztlumí.
Výhodou je, že můžeš hlasitost kdykoliv plynule upravit, místo úplného ztlumení.

* * *

Mám tam ten zvuk zkopírovaný do obou stop co dál?

hlas ve dvou stopách (L i R) a chceš z toho udělat stereo vhodné pro Vocoder. Tady je krok za krokem postup, jak připravit správně modulátor + carrier:

1️⃣ Připravit modulátor a carrier

Modulátor (hlas): vyber levou stopu (L) – to bude hlas, který se má anonymizovat.
Carrier (nosič): pravou stopu přepiš šumem (nebo jiným nosičem):
1. Klikni na pravou stopu, aby byla aktivní.
2. Generovat → Šum → Typ: Bílý, Amplituda: kolem 0,5, Délka: stejná jako hlasová stopa.

Teď máš:

L = hlas (modulátor)
R = bílý šum (carrier)

2️⃣ Vybrat obě stopy

Klikni do časové osy a označ obě stopy (nebo Ctrl+A v oblasti stop).

3️⃣ Aplikovat Vocoder

Menu: Efekty → Vocoder
Nastavení podle předchozího doporučení:
- Počet pásem: 20–25
- Rozkmit původního zvuku: 10–20 %
- Rozkmit bílého šumu: 70–80 %
- Rozkmit jehel radaru: 0 %

4️⃣ Export hotového zvuku

Po aplikaci efektu můžeš zkontrolovat, zda výsledek zní anonymně.
Export: Soubor → Exportovat → WAV nebo MP3.

🎯 Tip: Pokud chceš, aby hlas zněl ještě „temněji“ a roboticky, před Vocoderem použij Efekt → Změna výšky tónu (Pitch Shift) a snížíš hlas o 3–5 půltónů.

Chceš, abych ti teď připravil ukázkový postup v Audacity přesně krok za krokem od importu nahrávky po export, tak aby šel rovnou použít?

Jak zesílit stopu?

1️⃣ Použití efektu Amplify (Zesílit)

Vyber stopu, kterou chceš zesílit (klikni do její časové osy).
Menu: Efekty → Zesílit… (Amplify)
V okně nastav „Amplification (dB)“ – kladná hodnota = zesílení, záporná = snížení hlasitosti.
Klikni OK – stopa se upraví.

Tip: Pokud je zaškrtnuté „Allow clipping“ (povolit přebuzení), může dojít k deformaci zvuku. Lepší je nezaškrtávat a použít rozumné zesílení.

2️⃣ Použití Gain posuvníku

Na levé straně stopy je posuvník označený Gain.
Posuň doprava → zesílíš stopu, doleva → zeslabíš.
Toto je rychlejší, ale méně přesné než Amplify.

3️⃣ Normalizace (pro rovnoměrné zesílení celé stopy)

Efekty → Normalizovat…
Hodí se, když chceš, aby celá stopa byla na maximální možné úrovni bez přebuzení.

🎯 Tip: Pokud zesiluješ stopu, která půjde do Vocoderu, je lepší nejprve ji zesílit a pak aplikovat efekt. To zvýší účinnost „maskování“ hlasu.

* * *

Smíchání přirozeného hlasu s hlasem, kde byl aplikovaný effekt tremolo + vocer:

Když mám jednu stopu upravenou tím vocerem a druhou normální, ale ta první není moc srozumitelná je to jako poslouchat trubkou co někdo říká za zdá, tak dá se to nějak smíchat, aby hlas byl srozumitelnější, ale aby tam nebyl ten úplně originální hlas, který je dobře srozumitelný? Prostě vytvořit něco mezi dvěma stopama? Chci speciální efekt, který porovná dva signály a vytvoří něco mezi. Takový Vocoder2... Hledám něco inteligentnějšího než běžný mix, něco, co porovná dva signály (originální + Vocoder) a vytvoří hybridní stopu, která má zachovanou srozumitelnost, ale není originální.

To co popisuju, není klasický Vocoder, ani obyčejný mix – je to spíše formant-preserving morphing nebo signal morphing.

RE:

🔹 Princip

Analyzuje spektrum obou signálů (frequencí a formantů).
Interpoluje mezi nimi – bere charakter Vocoderu, ale část spektrální struktury originálního hlasu pro srozumitelnost.
Výsledkem je „mezi-verze“ hlasu – anonymní, ale stále dobře čitelná.

🔹 Software / pluginy, které to umí

Zynaptiq Zynaptiq Zynaptiq Morph / Zynaptiq Morph Bundle – komerční, high-end, podporuje Linux přes Wine/VM.
MeldaProduction MTransformer – plugin VST, umí morphing mezi dvěma zvuky (Linux přes Carla/DAW).
Spektrální morphing přes Pure Data nebo SuperCollider – open-source, plně konfigurovatelné.
Python + librosa / pyo – skriptově analyzuje dva zvuky a interpoluje frekvenční spektrum.

🔹 Poznámka

Audacity nenabízí „Vocoder2“ nebo spektrální morphing přímo.
Nejblíž, co v Audacity jde, je mix + EQ + kompresor + jemné doladění formantů, ale není to čistý morphing.

Takže mám soubor se stereo stopou; v jedné ten vocoderový modifikovaný hlas, a v druhé je původní hlas. Dej mi ten skript pro Python + librosa / pyo – skriptově analyzuje dva zvuky a interpoluje frekvenční spektrum.

Zbytek se dělá skriptem.

Ten skript funguje, jen ten původní soubor má tu druhou stopu více hlasitě, tak to asi musím zeslabit, aby nový hybridní hlas nebyl tak jasně slyšet.

Je to klasický mix problém – když je druhý kanál (originál) výrazně hlasitější než modifikovaný (vocoder), interpolace se „přitáhne“ k hlasitějšímu kanálu a hybridní efekt je utopený.

Možnost je zesílit/zeslabit kanály tak, aby měly přibližně stejnou RMS nebo max amplitudu:

# RMS normalizace (python)
rms_l = np.sqrt(np.mean(left**2))
rms_r = np.sqrt(np.mean(right**2))

left = left / rms_l * 0.8 # uprav 0.8 podle potřeby
right = right / rms_r * 0.8

Tím se vyrovná hlasitost a interpolace nebude „utopená“.

(Na mono stopu) PROBLÉM S VENKOVNÍM PROSTOREM A SLABOU HLASITOSTÍ ZVUKU

Maskování hlasu v uzavřené místnosti se povedlo s efektem 1. tremolo: počátek 0 stup. , ostrá úroveň 40 procent. Následně vocoder: vzdálenost 2, počet pásem 40, rozkmit původního 100%, rozkmit bílého šumu 10%, rozkmit jehel radaru 90%, kmitočet jehel 43,40 Hz. Následně jsem provedl mix s původním hlasem. Výsledkem byl efekt mírně robotického hlasu s občasným přebuzením. Nicméně v otevřeném prostoru venku je nižší hlasitost a zvýšený výskyt okolních zvuků a tyto stejné parametry voceru nejsou znát, není dosaženo stejného výsledku ačkoliv když mluvím sám sebe slyším docela dobře, ale ne tak hlasitě jako na nahrávce pořizované doma.

Tremolo

Počátek (Phase): 0°
Hloubka (Depth / Ostrá úroveň): 40 % (můžeš zkusit zvýšit na 50–60 %, aby efekt víc „prokousal“ i přes šum)
Frekvence (Rate): nech kolem 4–6 Hz – to dává přirozený „chvějící“ efekt hlasu.

👉 venku můžeš lehce zvýšit hloubku, aby byl efekt slyšitelnější i při nižší hlasitosti hlasu.

Vocoder (můj základ)

Vzdálenost (Spacing): 2
Počet pásem: 40 (doporučuji venku zvýšit na 60–80, aby zachytil víc detailů řeči)
Rozkmit původního zvuku: 100 % (venku zkus snížit na 70–90 %, aby originál nebyl tak dominantní)
Rozkmit bílého šumu: 10 % (venku zvýš na 20–30 %, bílý šum pomáhá zakrýt šum prostředí a zvýrazní maskovací efekt)
Rozkmit jehel radaru: 90 % (pokud slyšíš přebuzení, zkus snížit na 60–70 %)
Kmitočet jehel radaru: 43,4 Hz (to je OK, můžeš mírně experimentovat kolem 40–50 Hz)

Mix s originálem

Doma: 70 % vocoder + 30 % originál
Venku: raději 80–85 % vocoder + 15–20 % originál, protože originál je rušený šumem a přehluší efekt.

👉 Kombinace silnější tremolo (50–60 %) + více pásem ve vocoderu + více bílého šumu a menší podíl originálu ti dá slyšitelnější robotický/zkreslený hlas i venku.

* * *

Na tremolo beru hloubku 40, vocoder počet pásem 40 (80 je příliš silně robotický).

(Na mono stopu) Ted používám staré nastavení a je to příliš silné. To nedává smysl. je rozdíl v tom jestli ten vocoder aplikuju na stereo stopu nebo mono i když ve stereu jsou dvě stopy se stejným signálem?

* * *

Audacity Vocoder není psaný „kanálově“ úplně čistě:

některé jeho režimy (hlavně když je vstup stereo) používají levý kanál jako modulátor a pravý jako nositele;
pokud oba kanály obsahují totéž, výsledkem je „silnější“ nebo přebuzený efekt, protože signál se vlastně násobí sám sebou místo aby byl jen jeden vstup;
proto slyšíš rozdíl, i když stopy jsou identické.

Shrnutí

Mono stopa: vocoder → výsledek „normální“ síly.
Stereo stopa (oba kanály stejné): vocoder používá jeden kanál jako modulátor a druhý jako nositele → efekt je silnější, zkreslenější, někdy až přebuzený.

👉 Pokud chceš konzistentní výsledek a nemít to přebuzené:

pracuj jen v monu → aplikuj tremolo + vocoder,
a až nakonec si výsledek duplikuj do sterea (pro stereo export).

Zadání vychází ze souboru .mlt

# SEG A
ffmpeg -y -i "pokus.mp4" -ss 00:00:13.234 -to 00:00:18.634 -vf "eq=brightness=-0.05,format=gray" -an -c:v libx264 -preset veryfast -crf 18 "segA_mid_half.mp4"

# SEG B
ffmpeg -y -i "pokus.mp4" -ss 00:00:49.917 -to 00:00:54.050 -vf "eq=brightness=-0.05,format=gray" -an -c:v libx264 -preset veryfast -crf 18 "segB_mid_half.mp4"

# SEG C
ffmpeg -y -i "pokus.mp4" -ss 00:01:25.851 -to 00:02:37.284 -vf "eq=brightness=-0.05,format=gray" -an -c:v libx264 -preset veryfast -crf 18 "segC_mid_half.mp4"

# SEG D
ffmpeg -y -i "pokus.mp4" -ss 00:02:53.484 -to 00:03:04.284 -vf "eq=brightness=-0.05,format=gray" -an -c:v libx264 -preset veryfast -crf 18 "segD_mid_half.mp4"

První pokus s jednou oblastí:

ffmpeg -i frame_10s.png -filter_complex "[0:v]crop=30:57:110:225[left];[0:v][left]overlay=140:225[out]" -map "[out]" frame_masked.png

Ted dvě oblasti zamaskují modrý kovový vršek a modrou nálepku (tj. dvě oblasti):

ffmpeg -i frame_10s.png -filter_complex "
[0:v]crop=34:61:104:223[c1];
[0:v]crop=60:104:72:330[c2];
[0:v][c1]overlay=138:223[tmp];
[tmp][c2]overlay=132:330[out]
" -map "[out]" frame_masked.png

Nakonec chci hlavně udělat framu doprava, přímo ve videu, a následně to maskování framu.

ffmpeg -i "donio cuts horizontal.mp4" -filter_complex "
[0:v]transpose=1,split=3[base][c1src][c2src];
[c1src]crop=34:61:104:223[c1];
[c2src]crop=60:104:72:330[c2];
[base][c1]overlay=138:223[tmp];
[tmp][c2]overlay=132:330[out]
" -map "[out]" -c:v libx264 -crf 18 -preset veryfast -c:a copy "donio cuts vertical.mp4"

FFmpeg – vysvětlení filtrů a labelů

1. Co jsou hranaté závorky `[xxx]`

V filter_complex FFmpeg používáš hranaté závorky pro označení vstupů a výstupů filtrů:

[0:v] — první vstupní soubor, video stream.
[0:a] — první vstupní soubor, audio stream.
[c1], [base], [tmp], [out] — libovolná pojmenování mezivýstupů.

Tyto "labely" se používají v řetězci filtrů nebo v -map, aby FFmpeg věděl, který výsledek má použít.

2. Rozklad příkazu

Příkaz, který jsme používali:

ffmpeg -i "donio cuts horizontal.mp4" -filter_complex "
[0:v]transpose=1,split=3[base][c1src][c2src];
[c1src]crop=34:61:104:223[c1];
[c2src]crop=60:104:72:330[c2];
[base][c1]overlay=138:223[tmp];
[tmp][c2]overlay=132:330[out]
" -map "[out]" -c:v libx264 -crf 18 -preset veryfast -c:a copy "donio cuts vertical.mp4"

a) Otočení + split

[0:v]transpose=1,split=3[base][c1src][c2src];

- transpose=1 otočí video o 90° CW.
- split=3 vytvoří tři větve: [base], [c1src], [c2src].

b) Crop výřezů (záplat)

[c1src]crop=34:61:104:223[c1];
[c2src]crop=60:104:72:330[c2];

- crop=šířka:výška:x:y vystřihne obdélník ze zdrojové větve.
- Výstupy jsou pojmenovány [c1] a [c2].

c) Overlay první oblasti

[base][c1]overlay=138:223[tmp];

Překryje základní video [base] záplatou [c1] na pozici x=138, y=223. Výsledek pojmenuje [tmp].

d) Overlay druhé oblasti

[tmp][c2]overlay=132:330[out]

Překryje mezivýsledek [tmp] druhou záplatou [c2] na pozici x=132, y=330. Konečný výsledek je [out].

e) Mapování

-map "[out]"

Říká FFmpeg, aby použil label [out] jako video výstup. Bez mapování by FFmpeg nevěděl, který mezivýsledek exportovat.

3. Shrnutí

Labely jsou libovolné názvy; místo [out] můžeš použít [final].
Split vytváří paralelní větve obrazu.
Overlay překrývá jeden obraz na druhý.
Cruicial order: filtry se musí logicky propojit, vstupy musí odpovídat výstupům předchozích filtrů.
Audio: -c:a copy kopíruje zvuk beze změny.
Kvalita: -crf 18 -preset veryfast pro dobrou kvalitu a rychlost.

4. Test na obrázku

ffmpeg -i frame_10s.png -filter_complex "
[0:v]crop=34:61:104:223[c1];
[0:v]crop=60:104:72:330[c2];
[0:v][c1]overlay=138:223[tmp];
[tmp][c2]overlay=132:330[out]
" -map "[out]" frame_masked.png

* * *

PŘIDÁNÍ AUDIA DO VÝSTUPU

ffmpeg -i "donio cuts horizontal.mp4" -filter_complex "
[0:v]transpose=1,split=3[base][c1src][c2src];
[c1src]crop=34:61:104:223[c1];
[c2src]crop=60:104:72:330[c2];
[base][c1]overlay=138:223[tmp];
[tmp][c2]overlay=132:330[out]
" -map "[out]" -map 0:a -c:v libx264 -crf 18 -preset veryfast -c:a copy "donio cuts vertical.mp4"

Funguje opravdu skvěle.

ImageMagic - detekce

identify -verbose /media/user/HOGO/Documents/cz\ hotovo/*.jpg | grep CS2

Najde něco takového:

xap:CreatorTool: Adobe Photoshop CS2 Windows
xap:CreatorTool: Adobe Photoshop CS2 Windows

Vymazání tagu, hloubkově:

$ exiftool -r -overwrite_original -xap= "/media/user/HOGO/Documents/Donio.cz hotovo/"

Mint - Nastavení: Nastavení pracovního prostředí -> Správce oken: Vyladění

Tlačítko Vyladit Xfwm4

Změnit v kartě Přístupnost, na hoře klávesu místo Alt dát třeba Meta

Možná to pomůže po resetu.

Python 3

import librosa
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from dissonant import dissonance

# Načtení zvuku
y, sr = librosa.load("akord.wav")
freqs = librosa.fft_frequencies(sr=sr)
amps = np.abs(librosa.stft(y))

# Výpočet disonance (použijeme max pro lepší detekci vrcholů)
d = dissonance(freqs, amps.max(axis=1), model='sethares1993')

# Přizpůsobení dat pro 3D graf
x, y = np.meshgrid(freqs, freqs)
z = np.zeros_like(x)  # Inicializace nulovou maticí
num_elements = min(len(d), z.size)  # Omezit na dostupné prvky
z.flat[:num_elements] = d[:num_elements]  # Naplnění disonančními hodnotami

# Vytvoření 3D grafu
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
surf = ax.plot_surface(x, y, z, cmap='coolwarm')
ax.set_xlabel('Frekvence (Hz)')
ax.set_ylabel('Frekvence (Hz)')
ax.set_zlabel('Disonance')
plt.title("Disonance akordu")
plt.show()

Níže je upravený kód, který umožňuje přidat více akordů (zvukových souborů WAV) do seznamu, iteruje přes ně a vykresluje je jako oddělené vrstvy v 3D grafu. Každý akord bude mít jinou barvu nebo průhlednost pro rozlišení.

import librosa
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from dissonant import dissonance

# Seznam souborů s akordy
chord_files = ["akord1.wav", "akord2.wav", "akord3.wav", "akord4.wav"]  # Přidejte své soubory

# Inicializace grafu
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')

# Iterace přes všechny akordy
for i, file in enumerate(chord_files):
    # Načtení zvuku
    y, sr = librosa.load(file)
    freqs = librosa.fft_frequencies(sr=sr)
    amps = np.abs(librosa.stft(y))

    # Výpočet disonance
    d = dissonance(freqs, amps.max(axis=1), model='sethares1993')

    # Přizpůsobení dat pro 3D graf
    x, y = np.meshgrid(freqs, freqs)
    z = np.zeros_like(x)
    num_elements = min(len(d), z.size)
    z.flat[:num_elements] = d[:num_elements]

    # Vykreslení povrchu s různou barvou a průhledností
    surf = ax.plot_surface(x, y, z, cmap='coolwarm', alpha=0.5 - 0.1 * i, label=f'Akord {i+1}')
    ax.legend()

# Nastavení os a titulu
ax.set_xlabel('Frekvence (Hz)')
ax.set_ylabel('Frekvence (Hz)')
ax.set_zlabel('Disonance')
plt.title("Disonance více akordů")
plt.show()

Chytrý kontainer s klíči podle názvů jazyka a konfiguráku, drží hodnotu cestu ke konfiguráku a informaci zda soubor existuje. Troufám si tvrdit, že je to geniální.

     def __init__(self, langs: Lang, base_dir: str = '.'):
        self.langs = list(langs)
        # @TODO: POZOR - Lang.CZ JE JEN TEMPORARY DEBUG VALUE
        self.lang = Lang.CZ
        self.paths: dict[Lang, dict[str,str]] = {}
        self.files: Dict[Lang, Dict[str, List]] = {}
        for lang in self.langs:
            base = os.path.join(base_dir, 'lang', lang.value)
            self.paths[lang] = {
                'base':     base,
                'aff_dic': os.path.join(base, 'aff-dic'),
                'input':    os.path.join(base, 'input'),
                'output':   os.path.join(base, 'output'),
            }
            # 1) připravím si seznam adresář+název
            cfg_files = [
                (self.paths[lang]['base'],      "pfx.cfg"),
                (self.paths[lang]['aff_dic'],   "sfx.cfg"),
                (self.paths[lang]['output'],    "next.cfg")
            ]

            # 2) postavím dict fn -> [directory, exists]
            self.files[lang] = {
                fn: [
                    os.path.join(d,fn),
                    os.path.isfile(os.path.join(d, fn))
                ]
                for d, fn in cfg_files
            }

Dobře, pojďme se kouknout na dvě pokročilé techniky, které (pravděpodobně) ještě nemáš nasazené, a které ti během tisíců až milionů řádků ušetří desítky až stovky milisekund:

1) Aho–Corasick místo stovek tisíc `str.endswith` či regexů

Zatím pro každý řádek procházíš všechny tvé sufxy/prefxy a voláš na každý z nich r.matches(…), kde většinou testuješ word.endswith(literal) nebo malý regex. To je O(N_rules) práce pro každý vstupní řádek.

Co dělat místo toho

Sesbíráš všechny literal‑řetězce (ty bez hranatých závorek a tečky) do jednoho seznamu literals = ["at", "át", "absorbovat", …].
Postavíš Aho–Corasickův automat (trie + failure‑funkce) – existuje čistě C‑extenze pyahocorasick nebo ahocorasick.
S jedním průchodem nad každou vstupní řádkou (O(len(line))) získáš všechny literály, které v ní končí nebo začínají – včetně pozice.
Logiku PFX/SFX pak aplikuješ jen na ty, které skutečně pasují, místo abys testoval komplet všech pravidel.

Výsledek:

Místo for rule in aff_rules: if rule.matches(line): …
máš for match in aho_automaton.iter(line): …

Aho–Corasick dokáže pokrýt tisíce patternů v jednom průchodu C‑kódem, bez opakovaných volání Python‑funkcí. Výhoda je tím zřetelnější, čím víc pravidel máš.

2) Memory‑map (mmap) + bufferované čtení bez `.split()` a `.strip()`

Každé line.split('/', 1), .rstrip(), .startswith() či in jsou C‑funkce, ale volané desetitisíckrát dají dohromady značnou režii Pythonu.

Jak to oříznout

Místo

for raw in f:
    parts = raw.split('/',1)
    …

použij mmap, načti celý .dic soubor do paměti jako bytes, a pak ručně procházíš ukazatelem pozice

mm = mmap.mmap(f.fileno(), 0, access=mmap.ACCESS_READ)
pos = 0
while True:
    nl = mm.find(b'\n', pos)
    if nl == -1: break
    line = mm[pos:nl]      # jen pohled na paměť, nevytváří nový Python str
    pos = nl+1
    # pak hledáš pozici b'/' a b'[' nebo b']' jen pomocí .find() na bytes

bytes.find je implementováno v C a je extrémně rychlé.
Vytvoříš pohled na bytes, nikoliv novou str ani list parts.

Výsledkem je, že jsi celý diskový soubor přečetl do paměti jediným voláním OS, a každou řádku zpracováváš ~každý znak jen jednou bez Python‑level parsingových nástrojů.

Kombinace obou přístupů

Načti .dic přes mmap
Pro každý řádek vytáhni základ (base + flag) manuálně hledáním b'/', b'[' a b']' na byte‑level.
Na base (a případně reversed‑base) nech Aho–Corasick (nastavený na tvé substrings) v jednom průchodu najít všechny odpovídající aff‑patterny naráz.
Aplikuj jim apply() pouze na ty, co automat skutečně vrátil.

Co tím získáš

Zpracování řádku bude O(len(line) + #matches) místo O(#rules).
Celá smyčka čtení + parsování se propadne z desítek milisekund na jednotky.
Jediným Python‑voláním uvnitř velké smyčky je aho.iter() (která rovnou volá C‑kód) a ruční sestavení výstupu.

Toto jsou dvě techniky, které se běžně používají v nejrychlejších text‑processing nástrojích (např. grep‑like implementace) a myslím, že ti otevřou úplně jiný level výkonu, než dosavadní čistě‑Pythonová řešení.

* * *

Aff není bolest, ale ten .dic

Dobře, pojďme se zaměřit čistě na tu největší bolest: desítky tisíc řádek v .dic, kde teď děláš:

for line in f:
    if exclude …: continue
    parts = line.split('/',1)
    if flag in rest: entries.append(base)

Každé volání .split(), line[0] in … a „ruční“ filtrování v Python‑smyčce je to, co tě stojí ~500 ms. Místo toho můžeš zpracovat celý soubor najednou čistě v C pomocí jediné multiline‑regex!

Jednorázové „grep‑like“ vytažení base/flags z `.dic`

Načti celý .dic do str (nebo ještě lépe do bytes s mmap, viz níže).
Použij jeden re.compile s re.MULTILINE, který v C zpracuje všechny řádky:

import re

# exclude_pattern už např. "pro|na|do|u|roze?|…"
# flag je třeba escape‑nuté, např. "J"
combined = rf'''
    ^(?!{exclude_pattern})         # negativní lookahead pro exclude
    (?P<base>[^/\r\n]+)            # zachyť všechno až k '/'
    /[^\[]*\[{flag}\]              # pak cokoliv až k '[flag]'
'''
pattern = re.compile(combined, re.MULTILINE | re.VERBOSE)

with open(dic_path, 'r', encoding='utf-8') as f:
    text = f.read()
# tohle běží v C a uskočí po každém řádku, který projde lookahead i flagem
bases = pattern.findall(text)  # list of all base

Výhoda: celé parsování + filtrování exclude + extrakce base běží v C‑jádru regexu.
Výsledek: v bases máš ~70 000 položek během zlomku původního času.

Jak na mmap (ještě o chloupek rychleji)

import mmap

with open(dic_path, 'r+b') as f:
    mm = mmap.mmap(f.fileno(), 0, access=mmap.ACCESS_READ)
    # vytvoř pattern nad bytes, musíme de‑kódovat vlajky i exclude do byte‑level:
    pat = re.compile(rb'^(?!' + exclude_bytes + rb')([^/\r\n]+)/[^\[]*\[' + flag_bytes + rb'\]', re.MULTILINE)
    bases = [match.group(1).decode('utf-8') for match in pat.finditer(mm)]
    mm.close()

mmap načte celý soubor jediným systémovým voláním,
pat.finditer(mm) projde C‑kódem každý řádek,
vrátíš si jen group(1).

Reversed položky

Jakmile máš bases:

normal = bases
reversed_ = [w[::-1] for w in bases]  # Python‑level, ale jen O(n·avg_len)

A pak předáš normal i reversed_ do tvé dump_dic_forms.

Shrnutí

Namísto: Python‑smyčka + split + if exclude … + if flag in …
Použiješ: jeden re.compile(..., MULTILINE) + findall (nebo finditer), ideálně nad mmap.

Tohle ti z poolu ~500 ms vykleští do jednotek milisekund. A protože regex běží v C, už se nemusíš trápit hand‑rolled „first_letter“ hacky ani exclude_superfast.

Vyzkoušej tu jednou regex‑přístup a změř si čas znovu – srovnání bude dramatické.

Vrácení jako `dict`

def load_aff_rules(...) -> dict:
    rules = {'normal': [...], 'reversed': [...]}
    return rules

Výhody
- Čitelná pojmenovaná data: rules['normal'], rules['reversed'].
- Snadno se rozšiřuje o další klíče.
Nevýhody
- Nutnost pamatovat si přesné názvy klíčů – hrozí KeyError.
- Horší podpora statické kontroly typů (mypy, IDE).
- O něco pomalejší přístup kvůli hash‑lookup v dictu.

Vrácení jako `Tuple[List[AffRule], List[AffRule]]`

from typing import Tuple, List

def load_aff_rules(self, ...) -> Tuple[List[AffRule], List[AffRule]]:
    normal, reversed = [...], [...]
    return normal, reversed

a skutečně:

return rules['normal'], rules['reversed']

Výhody
- Jasně daná struktura: vždy dva seznamy ve stanoveném pořadí.
- Snadné rozbalení do proměnných:
```
normal_rules, reversed_rules = self.load_aff_rules(...)
```
- Lepší podpora statické kontroly typů díky Tuple[...].
- Rychlejší přístup (není potřeba dict‑lookup).
Nevýhody
- Méně samo‑dokumentující – musíte znát pořadí výstupů.
- Obtížnější rozšíření – přidání dalšího výstupu změní definici tuple i všech volání.

Použití čárek

V definici typu:

-> Tuple[List[AffRule], List[AffRule]]

čárka odděluje první a druhý seznam.

V návratové hodnotě:

return rules['normal'], rules['reversed']

čárka tu znamená, že Python vrátí 2‑prvkový tuple.

Dodatek: Chyba `AttributeError` při rozbalování `dict`

Chyba:

AttributeError: 'str' object has no attribute 'matches'

Tato chyba vzniká při nesprávném rozbalení návratové hodnoty z funkce, která vrací dict. Pokud máš následující kód:

aff_rules["normal"], aff_rules["reversed"] = self.load_aff_rules(...)

a funkce load_aff_rules vrací dict, dochází k tomu, že Python se snaží rozbalit klíče slovníku, ne jeho hodnoty. Výsledkem je:

aff_rules["normal"] == "normal"
aff_rules["reversed"] == "reversed"

což následně vede k chybě:

AttributeError: 'str' object has no attribute 'matches'

Řešení

Varianta A – Nechat návratový typ jako `dict`

Vrácený dict zachováš beze změny, ale rozbalíš ho ručně:

aff_rules = self.load_aff_rules(...)
normal_rules   = aff_rules["normal"]
reversed_rules = aff_rules["reversed"]

for w in dic_entries["normal"]:
    for r in normal_rules:
        if r.matches(w):
            dics_out["normal"].append(r.apply(w))

Varianta B – Vrátit `Tuple` místo `dict`

Pokud změníš návratovou hodnotu funkce na:

def load_aff_rules(...) -> Tuple[List[AffRule], List[AffRule]]:
    return rules["normal"], rules["reversed"]

pak volání funkce bude:

normal_rules, reversed_rules = self.load_aff_rules(...)

a zbytek kódu funguje stejně, ale s jistotou, že máš dva seznamy objektů typu AffRule.

Výhodou této varianty je lepší podpora typové kontroly (mypy, IDE), rychlejší přístup (není potřeba hash-lookup jako u dict) a menší riziko chyb typu KeyError.

* * *

def parse_aff_input(self, aff_path: str) -> list[dict]:

Vysvětlení deklarace výstupního typu

Funkce skutečně vrací seznam slovníků, kde každý slovník má přesně tyto klíče a hodnoty:

'regex': str
'substring': str
'replacement': str
'ext': str
'tags': List[str]

Původní podpis

def parse_aff_input(self, aff_path: str) -> list[dict]:

Toto je sice validní, ale statický typ dict neříká nic o tom, jaké klíče či hodnoty slovníky obsahují.

Konkrétní typová anotace

Můžeme si nejprve vytvořit TypedDict, aby bylo jasné, co v dictu očekáváme:

from typing import TypedDict, List

class AffRecord(TypedDict):
regex: str
substring: str
replacement: str
ext: str
tags: List[str]

A pak upravit deklaraci:

def parse_aff_input(self, aff_path: str) -> List[AffRecord]: ...

Alternativa bez `TypedDict`

Pokud nechcete zavádět TypedDict, můžete alespoň upřesnit hodnoty pomocí Union:

from typing import List, Dict, Union

def parse_aff_input(self, aff_path: str) -> List[Dict[str, Union[str, List[str]]]]:
...

Tím dáváte najevo, že každá položka seznamu je slovník s řetězcovými klíči a hodnotami buď str nebo List[str].

Chyba - velmi matoucí: Funkce očekává 1 poziční argument

$ ./affdic-processor.py
Trvání: 56.909 ms
Traceback (most recent call last):
File "/home/user/Skripty/Python.čeština/czech-dictionaries/./affdic-processor.py", line 536, in <module>
    proc.dump_dic_forms( RuleType.SFX, 'J',
File "/home/user/Skripty/Python.čeština/czech-dictionaries/./affdic-processor.py", line 436, in dump_dic_forms
    aff_rules["normal"], aff_rules["reversed"] = self.load_aff_rules(rule_type, flag)
File "/home/user/Skripty/Python.čeština/czech-dictionaries/./affdic-processor.py", line 231, in load_aff_rules
    raw = self.parse_aff_input(aff_path)
TypeError: AffDicProcessor.parse_aff_input() takes 1 positional argument but 2 were given

Jedná se o funkci, kterou napsal GPT def parse_aff_input(self, aff_path: str) -> list[dict]: , ale při implementaci do třídy jsem zapomněl přidat self jako první argument: def parse_aff_input(self, aff_path: str) -> list[dict]:

volání uvnitř jiné metody: raw = self.parse_aff_input(aff_path)

GPT tuto chybu vysvětluje:"jsi definoval metodu," ... "ale voláš ji jako instanční metodu... " "Řešení: Přidat self do signatury" nebo "Použít @staticmethod" a volat ji takto: AffDicProcessor.parse_aff_input(aff_path)

Zkoušel jsem test.

Původní řešení pro exclude regex prostě používalo regex na každý řádek slovníku, který splňoval dané podmínky. Čas zpracování smyčky byl cca 470ms. Byl to obyčejná exclude_str v podstatě řetězec s alternativama.

$ ./affdic-processor.py
Trvání: 48.915 ms
dump aff smyčka zápis ve smyčce - Trvání: 48.293 ms
Wrote ./lang/cs_CZ/input/SFX-J.aff (379 rules)
Load aff rules: Trvání: 48.637 ms
smyčka s exclude Trvání: 470.289 ms
Load .dic entries: Trvání: 513.712 ms
Wrote ./lang/cs_CZ/input/SFX-J.txt (65387 items)
Wrote ./lang/cs_CZ/input/SFX-J.r.txt (874 items)
Load aff rules - zápis max. dvou souborů: Trvání: 6238.581 ms
(.venv) user@Toshi:~/Skripty/Python.čeština/czech-dictionaries$

NEEFEKTIVNÍ ŘEŠENÍ, EFEKTIVITA SE ZTRÁCÍ NA DVOU ZANOŘENÝCH SMYČKÁCH for

Zkoušel jsem to nahradit za dva seznamy nebo pole a seznam, a dát tomu sofistikovanější logiku, ale smyčka s exclude ted trvá 871 ms...

~/Skripty/Python.čeština/czech-dictionaries$ ./affdic-processor.py
Trvání: 61.627 ms
dump aff smyčka zápis ve smyčce - Trvání: 52.694 ms
Wrote ./lang/cs_CZ/input/SFX-J.aff (379 rules)
Load aff rules: Trvání: 67.405 ms
smyčka s exclude Trvání: 871.273 ms
Load .dic entries: Trvání: 915.141 ms
Wrote ./lang/cs_CZ/input/SFX-J.txt (45952 items)
Wrote ./lang/cs_CZ/input/SFX-J.r.txt (425 items)
Load aff rules - zápis max. dvou souborů: Trvání: 4408.855 ms

    def extract_dic_entries(self, flag: str,
        exclude_prefixes: dict = None,
        compiled_exclude_regex: dict = None,
        exclude_superfast: bool=True,
        reverse: dict = None
        ) -> list:
        reverse = reverse or {"input": False, "output": False}

        """
        Vyhledá v .dic všechny tvary s daným flagem.
        Regex vybírá část před slash '/' a kontroluje, zda mezi hranatými
        závorkami je zadaný flag (např. IN pro I a N).
        Pro eliminaci předpon, lze doplnit grep-like filtr: např. odmítat
        řádky začínající na pro|na|do|..."""
        dic_path = os.path.join(self.aff_dic_dir, f"{self.lang.value}.dic")
        entries = []
        # pattern = re.compile(rf"^(\S+)/.*?\[{flag}\]")
        """
        if exclude_str:
            if exclude_superfast:
                gen = (part[0] for part in exclude_str.split("|") if part)
                exclude_first_letters = list(dict.fromkeys(gen))
            exclude = re.compile(rf"^(?:{exclude_str})")
        """
        start = time.perf_counter()
        with open(dic_path, encoding='utf-8') as f:
            next(f) # skip header count
            for line in f:

                if exclude_superfast:
                    break_prim = False
                    for p in exclude_prefixes["keys"]:
                        if p == line[0]:
                            if len(line)>1:
                                for sec in exclude_prefixes[line[0]]:
                                    if sec[1] == line[1]:
                                        if len(sec)>2 and line.startswith(sec):
                                            if compiled_exclude_regex[p].match(line):
                                                break_prim = True
                                                break
                                        else:
                                            break_prim = True
                                            break
                                    else:
                                        break_prim = True
                                        break
                            else:
                                break_prim = True
                                break
                        # u jiných počátečních písmen spustit obecný regex přímo
                        elif compiled_exclude_regex['.'].match(line):
                            break_prim = True
                            break
                        if break_prim == True:
                            break
                if break_prim == True:
                    continue



                # rozdělíme na část před '/' a za '/':
                # např. "být/IN" -> base="být", rest="IN"

                # Pokud uživatel nezadal flag, pak zapisovat jen slovíčka bez vlajek
                parts = line.split('/', 1)
                if not flag and len(parts)==1:
                    entries.append(line)
                    continue
                elif len(parts) != 2:
                    continue
                base, rest = parts
                # rest může obsahovat příznaky a další text, např. "IN", "PIN", "HRIN"
                if flag in rest:
                    entries.append(base)
        for _ in range(1000000):
            pass
        end = time.perf_counter(); elapsed_ms = (end - start) * 1000; print(f"smyčka s exclude Trvání: {elapsed_ms:.3f} ms")

        return entries

HLAVNÍ ČÁST KODU:

if __name__ == '__main__':
    reverse={
            "input": False,
            "output": False
            }
    # Ukázkové volání: vytvoříme procesor, načteme .aff/Shapka a zpracujeme text
    proc = AffDicProcessor(Lang.CZ)
    # 1) Vygeneruješ zkrácený .aff se všemi pravidly SFX‑J
    proc.dump_aff_rules(RuleType.SFX, 'J', reverse=reverse)

   # 2) Na základě těch samých pravidel plus .dic entries vypíšeš tvary:
    #    normalně i v obráceném pořadí, s použitím stejného exclude filtru

    # PŮVODNÍ ŘETĚZEC:
    # exclude_str="pro|na|do|u|roze?|přede?|př[ei]|po|za|vy|ode?|obe?|znovu|spolu"
    # ZKUSÍM TO VYLEPŠIT:

    # exclude_prefixes -NESMÍ OBSAHOVAT REGEXY
    exclude_prefixes = {
        'keys': ['p', 'o', 'z'],
        'p': ["po", "př"], # "pro"- neotestováno
        'o': ["od", "ob"],
        'z': ["za", "znovu"]
    }
    exclude_regex_map = {
        'p': ["po|přede?|př[ei]"],
        'o': ["ode?|obe?"],
        'z': ["za|znovu"],
        '.': ["na|do|u|roze?|vy|spolu"]
    }
    compiled_exclude_regex = {}
    for first, patterns in exclude_regex_map.items():
        group = "|".join(patterns)
        # ^ → match na začátku řádky
        compiled_exclude_regex[first] = re.compile(fr"^(?:{group})")

    proc.dump_dic_forms( RuleType.SFX, 'J',
        reverse=reverse,
        exclude_prefixes=exclude_prefixes,
        compiled_exclude_regex=compiled_exclude_regex
         )

KOD KTERÝ BYL RYCHLEJŠÍ (starý dvoujádrový notebook celeron z roku 2009)

    def extract_dic_entries(self, flag: str,
        exclude_str: str = "",
        exclude_superfast: bool=True,
        reverse: dict = None
        ) -> list:
        reverse = reverse or {"input": False, "output": False}

        dic_path = os.path.join(self.aff_dic_dir, f"{self.lang.value}.dic")
        entries = []
        # pattern = re.compile(rf"^(\S+)/.*?\[{flag}\]")
        if exclude_str:
            if exclude_superfast:
                gen = (part[0] for part in exclude_str.split("|") if part)
                exclude_first_letters = list(dict.fromkeys(gen))
            exclude = re.compile(rf"^(?:{exclude_str})")
        start = time.perf_counter()
        with open(dic_path, encoding='utf-8') as f:
            next(f) # skip header count
            for line in f:

                if exclude_str:
                    if exclude_superfast:
                        # superfast: nejprve zkontrolovat první písmeno,
                        # až pak volat regex jen pro podezřelé řádky
                        if line[0] in exclude_first_letters and exclude.match(line):
                            continue
                    else:
                        # bez superfast: grep‑like filtrování pro všechny řádky
                        if exclude.match(line):
                            continue

                # rozdělíme na část před '/' a za '/':
                # např. "být/IN" -> base="být", rest="IN"

                # Pokud uživatel nezadal flag, pak zapisovat jen slovíčka bez vlajek
                parts = line.split('/', 1)
                if not flag and len(parts)==1:
                    entries.append(line)
                    continue
                elif len(parts) != 2:
                    continue
                base, rest = parts
                # rest může obsahovat příznaky a další text, např. "IN", "PIN", "HRIN"
                if flag in rest:
                    entries.append(base)
        for _ in range(1000000):
            pass
        end = time.perf_counter(); elapsed_ms = (end - start) * 1000; print(f"smyčka s exclude Trvání: {elapsed_ms:.3f} ms")

        return entries

# === Příklad použití ===
if __name__ == '__main__':
    reverse={
            "input": False,
            "output": False
            }
    # Ukázkové volání: vytvoříme procesor, načteme .aff/Shapka a zpracujeme text
    proc = AffDicProcessor(Lang.CZ)
    # 1) Vygeneruješ zkrácený .aff se všemi pravidly SFX‑J
    proc.dump_aff_rules(RuleType.SFX, 'J', reverse=reverse)

   # 2) Na základě těch samých pravidel plus .dic entries vypíšeš tvary:
    #    normalně i v obráceném pořadí, s použitím stejného exclude filtru
    proc.dump_dic_forms( RuleType.SFX, 'J',
        reverse=reverse,
        exclude_str="pro|na|do|u|roze?|přede?|př[ei]|po|za|vy|ode?|obe?|znovu|spolu" )

Je statický přístup rychlejší? Ne: 639ms.

    def extract_dic_entries(self, flag: str,
        exclude_prefixes: dict = None,
        compiled_exclude_regex: dict = None,
        exclude_superfast: bool=True,
        reverse: dict = None
        ) -> list:
        reverse = reverse or {"input": False, "output": False}

        """
        Vyhledá v .dic všechny tvary s daným flagem.
        Regex vybírá část před slash '/' a kontroluje, zda mezi hranatými
        závorkami je zadaný flag (např. IN pro I a N).
        Pro eliminaci předpon, lze doplnit grep-like filtr: např. odmítat
        řádky začínající na pro|na|do|..."""
        dic_path = os.path.join(self.aff_dic_dir, f"{self.lang.value}.dic")
        entries = []
        # pattern = re.compile(rf"^(\S+)/.*?\[{flag}\]")
        start = time.perf_counter()
        with open(dic_path, encoding='utf-8') as f:
            next(f) # skip header count
            for line in f:

                if exclude_superfast:
                    # superfast: nejprve zkontrolovat první písmeno,
                    # až pak volat regex jen pro podezřelé řádky
                    """
                    if line[0] in exclude_first_letters and exclude.match(line):
                        continue
                    """
                    if line[0] == exclude_prefixes['keys_3'][0]:
                        if compiled_exclude_regex['p'].match(line):
                          continue
                    elif line[0] == exclude_prefixes['keys_3'][1]:
                        if compiled_exclude_regex['o'].match(line):
                          continue
                    elif line[0] == exclude_prefixes['keys_3'][2]:
                        if compiled_exclude_regex['z'].match(line):
                          continue
                    elif line[0] in exclude_prefixes['rest_keys'].find():
                        if compiled_exclude_regex['.'].match(line):
                          continue
                else:
                    # bez superfast: grep‑like filtrování pro všechny řádky
                    if exclude.match(line):
                        continue

                # rozdělíme na část před '/' a za '/':
                # např. "být/IN" -> base="být", rest="IN"

                # Pokud uživatel nezadal flag, pak zapisovat jen slovíčka bez vlajek
                parts = line.split('/', 1)
                if not flag and len(parts)==1:
                    entries.append(line)
                    continue
                elif len(parts) != 2:
                    continue
                base, rest = parts
                # rest může obsahovat příznaky a další text, např. "IN", "PIN", "HRIN"
                if flag in rest:
                    entries.append(base)
        for _ in range(1000000):
            pass
        end = time.perf_counter(); elapsed_ms = (end - start) * 1000; print(f"smyčka s exclude Trvání: {elapsed_ms:.3f} ms")

        return entries

if __name__ == '__main__':
    reverse={
            "input": False,
            "output": False
            }
    # exclude_prefixes - obsahuje první znaky u třech předloh a zbýv.
    exclude_prefixes = {
        'keys_3': ['p', 'o', 'z'],
        'rest_keys': "dnrvs"
    }
    exclude_regex_map = {
        'p': ["po|přede?|př[ei]"],
        'o': ["ode?|obe?"],
        'z': ["za|znovu"],
        '.': ["do|na|roze?|vy|spolu"] # "u" nelze zařadit, je ve slově "usnout"a "snout" nemá význam
    }
    compiled_exclude_regex = {}
    for first, patterns in exclude_regex_map.items():
        group = "|".join(patterns)
        # ^ → match na začátku řádky
        compiled_exclude_regex[first] = re.compile(rf"^(?:{group})")

    # Ukázkové volání: vytvoříme procesor, načteme .aff/Shapka a zpracujeme text
    proc = AffDicProcessor(Lang.CZ)
    # 1) Vygeneruješ zkrácený .aff se všemi pravidly SFX‑J
    proc.dump_aff_rules(RuleType.SFX, 'J', reverse=reverse)

   # 2) Na základě těch samých pravidel plus .dic entries vypíšeš tvary:
    #    normalně i v obráceném pořadí, s použitím stejného exclude filtru
    proc.dump_dic_forms( RuleType.SFX, 'J',
        reverse=reverse,
        # exclude_str="pro|na|do|u|roze?|přede?|př[ei]|po|za|vy|ode?|obe?|znovu|spolu"
        exclude_prefixes=exclude_prefixes,
        compiled_exclude_regex=compiled_exclude_regex )

Je statický přístup s str.find(line[0]) rychlejší? Ne: 848ms.

To samé co výše jen s exclude_prefixes['rest_keys'].find(line[0])

čtvrtek 11. září 2025

Kde najdeš efekt Vocoder

Jak funguje Vocoder

🔧 Doporučené nastavení Vocoderu v Audacity

📋 Vysvětlení jednotlivých voleb:

🔧 Doporučené nastavení pro anonymizaci hlasu (styl „TV pořad 90. let“)

🎧 Tip na vylepšení

🛠 Postup, jak přidat druhou stopu (pravý kanál)

🎧 Tip

🔹 Jak vybrat levý kanál stereo stopy

🎧 Tipy navíc

1️⃣ Použití tlačítka Mute

2️⃣ Použití posuvníku Gain

1️⃣ Připravit modulátor a carrier

2️⃣ Vybrat obě stopy

3️⃣ Aplikovat Vocoder

4️⃣ Export hotového zvuku

1️⃣ Použití efektu Amplify (Zesílit)

2️⃣ Použití Gain posuvníku

3️⃣ Normalizace (pro rovnoměrné zesílení celé stopy)

🔹 Princip

🔹 Software / pluginy, které to umí

🔹 Poznámka

Tremolo

Vocoder (můj základ)

Mix s originálem

Shrnutí

středa 10. září 2025

úterý 9. září 2025

FFmpeg – vysvětlení filtrů a labelů

1. Co jsou hranaté závorky [xxx]

2. Rozklad příkazu

a) Otočení + split

b) Crop výřezů (záplat)

c) Overlay první oblasti

d) Overlay druhé oblasti

e) Mapování

3. Shrnutí

4. Test na obrázku

pátek 5. září 2025

neděle 17. srpna 2025

neděle 10. srpna 2025

středa 30. července 2025

sobota 19. července 2025

1) Aho–Corasick místo stovek tisíc str.endswith či regexů

Co dělat místo toho

2) Memory‑map (mmap) + bufferované čtení bez .split() a .strip()

Jak to oříznout

Kombinace obou přístupů

Co tím získáš

Jednorázové „grep‑like“ vytažení base/flags z .dic

Jak na mmap (ještě o chloupek rychleji)

Reversed položky

Shrnutí

Vrácení jako dict

Vrácení jako Tuple[List[AffRule], List[AffRule]]

Použití čárek

Dodatek: Chyba AttributeError při rozbalování dict

Řešení

Varianta A – Nechat návratový typ jako dict

Varianta B – Vrátit Tuple místo dict

Vysvětlení deklarace výstupního typu

Původní podpis

Konkrétní typová anotace

Alternativa bez TypedDict

pátek 18. července 2025

čtvrtek 17. července 2025

Štítky

1. Co jsou hranaté závorky `[xxx]`

1) Aho–Corasick místo stovek tisíc `str.endswith` či regexů

2) Memory‑map (mmap) + bufferované čtení bez `.split()` a `.strip()`

Jednorázové „grep‑like“ vytažení base/flags z `.dic`

Vrácení jako `dict`

Vrácení jako `Tuple[List[AffRule], List[AffRule]]`

Dodatek: Chyba `AttributeError` při rozbalování `dict`

Varianta A – Nechat návratový typ jako `dict`

Varianta B – Vrátit `Tuple` místo `dict`

Alternativa bez `TypedDict`