vvv

Výkonové nastavení Firefoxu a glx test při startu

 

1. Dá se prohlížeč Firefox nakonfigurovat tak, aby se při startu spouštěl menší počet vláken? Aby například najely jen dvě podvlákna? Jsou očíslovaní ChildID1 a ChildID2 a spouští se pak další ChildID3 ChildID4 ChildID5 atd. A mě stačí dvě ChildID1 a ChildID2. 2. Dá se nakonfigurovat Firefox tak, aby se nespouštěl glx test při startu?

1. Nastavení počtu vláken v prohlížeči Firefox: Firefox standardně používá více vláken pro zpracování různých úloh, což může zlepšit výkon. Nicméně, není přímo možné omezit počet spuštěných vláken (ChildID) na konkrétní číslo, jako jsou pouze dvě. Můžete však zkusit upravit některé parametry v konfiguraci Firefoxu:

   • Otevřete Firefox a do adresního řádku zadejte about:config.
   • Potvrďte, že chcete pokračovat (pokud se zobrazí varování).
   • Hledejte nastavení jako dom.ipc.processCount, které určuje počet procesů pro zpracování. Můžete zkusit nastavit tuto hodnotu na 2, ale mějte na paměti, že to může ovlivnit výkon a stabilitu prohlížeče.

   Upozorňuji, že změny v about:config mohou mít nečekané důsledky, takže je dobré si být vědom rizik.

2. Vypnutí GLX testu při startu: GLX testy se obvykle provádějí pro zajištění správného fungování grafického zobrazení. Pokud chcete tyto testy vypnout, můžete zkusit následující:

   • Otevřete about:config v prohlížeči Firefox.
   • Hledejte nastavení jako gfx.webrender.all a nastavte ho na false, což může pomoci s některými grafickými testy.
   • Další možností je hledat layers.acceleration.disabled a nastavit ho na true, což by mělo zakázat hardware akceleraci.

   Opět platí, že změny v těchto nastaveních mohou ovlivnit výkon a stabilitu prohlížeče, takže je dobré být opatrný.

co znamená položka v nastavení firefoxu: gfx.webrender.all-partial-present-buffer-age ?

Položka gfx.webrender.all-partial-present-buffer-age v nastavení Firefoxu se týká WebRenderu, což je grafický rendering engine, který Firefox používá pro zlepšení výkonu a kvality zobrazení. Tato konkrétní položka se zaměřuje na správu věku (age) bufferů, které jsou použity pro částečné vykreslování (partial rendering).

Vysvětlení jednotlivých částí:

• gfx: Odkazuje na grafické nastavení.
• webrender: Odkazuje na WebRender, rendering engine, který je navržen tak, aby využíval moderní grafické API a hardware akceleraci pro zlepšení výkonu.
• all-partial-present-buffer-age: Tato část se týká věku bufferů, které jsou prezentovány částečně. Věk bufferu může ovlivnit, jak dlouho je buffer uchováván před tím, než je znovu použit nebo zničen.

Toto nastavení může mít vliv na výkon a kvalitu vykreslování, zejména v situacích, kdy se vykreslují pouze části obrazovky (například při animacích nebo při posouvání). Změna této hodnoty může mít dopad na to, jak efektivně Firefox spravuje grafické zdroje a jak rychle reaguje na změny v obsahu.

Hlavičky: Časová platnost různých položek (Cache-Conrol, Expires, Set Cookie, ETag, Last-Modified, Max-Age))

V hlavičkách odpovědí od serveru mohou být uvedeny informace o době platnosti různých položek, zejména pokud jde o cache, cookies a další prvky spojené s platností dat. Pojďme se podívat na některé z hlaviček, které se týkají doby platnosti:

1. Cache-Control

• Například hlavička Cache-Control: no-cache znamená, že obsah by neměl být cachován, což znamená, že pro každou novou žádost by měl klient znovu požádat server o aktualizovanou verzi obsahu.
• V jiné hlavičce může být např. Cache-Control: public, immutable, max-age=3600, což znamená, že obsah může být cachován až 3600 sekund (1 hodina) a během této doby nemusí klient znovu požadovat aktualizaci.

2. Expires

• Tato hlavička určuje přesný čas, kdy data přestanou být považována za aktuální. Například hlavička:
  • Expires: Thu, 12 Sep 2024 10:51:14 GMT znamená, že obsah je platný do tohoto data a času. Po tomto okamžiku se očekává, že klient požádá server o novou verzi obsahu.

3. Set-Cookie

• Cookies mohou mít vlastní dobu platnosti pomocí atributu Expires. Například:
  • Set-Cookie: kdojeto=731244171; expires=Wed, 25-Dec-2024 14:51:14 GMT znamená, že cookie kdojeto je platná do 25. prosince 2024. Po tomto datu bude cookie neplatná a klient ji bude muset znovu získat.

4. ETag a Last-Modified

• Tyto hlavičky se týkají mechanismu validace cache:
  • ETag je identifikátor verze obsahu. Pokud se obsah změní, ETag se změní, což umožňuje klientovi zjistit, zda je jeho verze stále aktuální.
  • Last-Modified udává poslední datum a čas, kdy byl obsah na serveru upraven. Pokud je obsah stále stejný od daného data, klient může obsah z cache použít, pokud má stejnou verzi.

5. Max-Age

• Tato hlavička definuje maximální dobu (v sekundách), po kterou může být obsah cachován. Například:
  • Cache-Control: max-age=3600 znamená, že obsah může být považován za aktuální po dobu 3600 sekund (1 hodina).

curl: Simulace komunikace se serverem

Pokračuji v předchozím článku o curl a hlavíčkách (stahování souborů a hlavičky).

Pro simulaci celé komunikace, jak je popsána v minulém díle o hlavičkách, můžeme použít curl v Bashi s nastavenými hlavičkami pro oba požadavky – první požadavek na HTML soubor ze serveru zp....cz a druhý požadavek na JavaScript soubor ze serveru freeprivacypolicy.com. Ukážeme, jak přesně nasimulovat odesílání hlaviček a zpracování odpovědí. Níže je ukázka:

1. První požadavek: Stažení HTML souboru z zp....cz

curl -X GET "https://zp....cz/" \
  -H "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/png,image/svg+xml,*/*;q=0.8" \
  -H "Accept-Encoding: gzip, deflate, br, zstd" \
  -H "Accept-Language: cs,sk;q=0.8,en-US;q=0.5,en;q=0.3" \
  -H "Connection: keep-alive" \
  -H "DNT: 1" \
  -H "Host: zp....cz" \
  -H "Priority: u=0, i" \
  -H "Sec-Fetch-Dest: document" \
  -H "Sec-Fetch-Mode: navigate" \
  -H "Sec-Fetch-Site: none" \
  -H "Sec-Fetch-User: ?1" \
  -H "Sec-GPC: 1" \
  -H "Upgrade-Insecure-Requests: 1" \
  -H "User-Agent: Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:130.0) Gecko/20100101 Firefox/130.0" \
  --compressed --verbose

Parametr -X v příkazu curl specifikuje HTTP metodu, kterou chceš použít pro daný požadavek. Ve tvém případě:

• -X GET říká curl, aby použil metodu GET, což je nejběžnější metoda pro získání dat z URL (např. stažení webové stránky nebo souboru). Ve většině případů curl implicitně používá metodu GET, takže tento parametr není nutný, pokud neplánuješ použít jinou metodu (např. POST, PUT, DELETE).

2. Druhý požadavek: Stažení JavaScript souboru z freeprivacypolicy.com

curl -X GET "https://www.freeprivacypolicy.com/public/cookie-consent/4.0.0/cookie-consent.js" \
  -H "Accept: */*" \
  -H "Accept-Encoding: gzip, deflate, br, zstd" \
  -H "Accept-Language: cs,sk;q=0.8,en-US;q=0.5,en;q=0.3" \
  -H "Connection: keep-alive" \
  -H "DNT: 1" \
  -H "Host: www.freeprivacypolicy.com" \
  -H "Priority: u=2" \
  -H "Referer: https://zp....cz/" \
  -H "Sec-Fetch-Dest: script" \
  -H "Sec-Fetch-Mode: no-cors" \
  -H "Sec-Fetch-Site: cross-site" \
  -H "Sec-GPC: 1" \
  -H "User-Agent: Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:130.0) Gecko/20100101 Firefox/130.0" \
  --compressed --verbose

Vysvětlení parametrů:

• -H – nastavuje hlavičky požadavku.
• --compressed – povoluje podporu kompresí jako gzip, br, deflate.
• --verbose – zobrazí detaily komunikace, včetně přijatých a odeslaných hlaviček, což simuluje sledování celé komunikace.

Tímto způsobem bude curl odesílat požadavky s příslušnými hlavičkami a zpracovávat odpovědi, jak jsou uvedeny v komunikaci.

Uložení cookies

Hlavičky odpovědi, zejména cookies, jsou velmi důležité pro následné požadavky na stejný server. Když server v odpovědi nastaví cookies (například Set-Cookie), klient (v tomto případě tvůj Bash skript s curl) by měl tyto cookies uložit a použít je při dalších požadavcích. Tyto cookies mohou sloužit k udržení stavu session (např. pomocí PHPSESSID) nebo k identifikaci uživatele (např. pomocí kdojeto).

Jak správně zpracovat hlavičky odpovědi a cookies pomocí curl:

1. Ukládání cookies: Když server nastaví cookies, je potřeba je uložit do souboru, abys je mohl při dalších požadavcích použít.
2. Zasílání cookies zpět: Při dalších požadavcích je nutné tyto uložené cookies posílat zpět na server, aby mohl server pokračovat v komunikaci na základě session nebo jiných informací.

Simulace v Bash pomocí curl:

Zde je skript, který provede:

• Stažení HTML stránky a uložení cookies do souboru.
• Stažení JS souboru s použitím těchto cookies a simulací hlaviček.

#!/bin/bash

# URL serveru
BASE_URL="https://zp...cz"
JS_URL="https://www.freeprivacypolicy.com/public/cookie-consent/4.0.0/cookie-consent.js"

# Soubor, do kterého se uloží cookies
COOKIE_FILE="cookies.txt"

# První požadavek - stáhnutí HTML
curl -s -c "$COOKIE_FILE" \
  -H "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/png,image/svg+xml,*/*;q=0.8" \
  -H "Accept-Encoding: gzip, deflate, br, zstd" \
  -H "Accept-Language: cs,sk;q=0.8,en-US;q=0.5,en;q=0.3" \
  -H "Connection: keep-alive" \
  -H "DNT: 1" \
  -H "Host: zp....cz" \
  -H "Sec-Fetch-Dest: document" \
  -H "Sec-Fetch-Mode: navigate" \
  -H "Sec-Fetch-Site: none" \
  -H "Sec-Fetch-User: ?1" \
  -H "Upgrade-Insecure-Requests: 1" \
  -H "User-Agent: Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:130.0) Gecko/20100101 Firefox/130.0" \
  "$BASE_URL/"

# Druhý požadavek - stažení JS souboru s použitím uložených cookies
curl -s -b "$COOKIE_FILE" \
  -H "Accept: */*" \
  -H "Accept-Encoding: gzip, deflate, br, zstd" \
  -H "Accept-Language: cs,sk;q=0.8,en-US;q=0.5,en;q=0.3" \
  -H "Connection: keep-alive" \
  -H "DNT: 1" \
  -H "Host: www.freeprivacypolicy.com" \
  -H "Referer: $BASE_URL/" \
  -H "Sec-Fetch-Dest: script" \
  -H "Sec-Fetch-Mode: no-cors" \
  -H "Sec-Fetch-Site: cross-site" \
  -H "User-Agent: Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:130.0) Gecko/20100101 Firefox/130.0" \
  "$JS_URL"

Vysvětlení:

1. První curl příkaz stáhne HTML stránku a uloží cookies do souboru cookies.txt. Používáme různé hlavičky, jako například Accept-Encoding a User-Agent, aby komunikace vypadala jako běžný prohlížeč.

2. Druhý curl příkaz stáhne JS soubor, ale tentokrát použije uložené cookies (-b "$COOKIE_FILE"). Zasíláme také hlavičku Referer, která ukazuje, odkud byl požadavek odeslán (v tomto případě z zp....cz).

Proč jsou důležité odpovědi serveru?

• Cookies: Slouží pro udržení session nebo autentizaci uživatele. Například PHPSESSID udržuje stav session mezi požadavky.
• Cache-Control: Ovládá cacheování. Hlavička no-cache znamená, že by obsah neměl být uložen do cache.
• Content-Encoding: Uvádí, jak je odpověď komprimována (např. gzip, br), což je důležité, pokud chceš odpověď správně rozbalit a zpracovat.
• X-Powered-By: Informuje, na jaké technologii server běží (zde PHP a ASP.NET).

Uložení hlaviček a kontrola

Chcete-li uložit hlavičky odpovědi do souborů a následně kontrolovat, zda soubor již existuje na disku a nestahovat jej znovu, můžete v Bashi použít curl spolu s dalšími nástroji jako grep nebo head.

1. Uložení hlaviček odpovědi do souboru

Pomocí curl můžete uložit hlavičky odpovědi do samostatného souboru a tělo odpovědi (např. JS soubor) do jiného:

# Stáhne hlavičky a uloží je do souboru headers.txt, tělo uloží do file.js
curl -D headers.txt -o file.js "https://www.freeprivacypolicy.com/public/cookie-consent/4.0.0/cookie-consent.js"

2. Kontrola, zda je soubor již stažen

Před každým stahováním můžete zkontrolovat, zda soubor již existuje na disku:

# Zkontroluje, zda soubor file.js existuje
if [ -f "file.js" ]; then
    echo "Soubor již existuje, nestahovat."
else
    echo "Soubor neexistuje, stáhne se nyní."
    curl -D headers.txt -o file.js "https://www.freeprivacypolicy.com/public/cookie-consent/4.0.0/cookie-consent.js"
fi

3. Kontrola hlavičky 303 See Other

Hlavička 303 indikuje, že klient by měl použít jiný zdroj (URL) pro požadavek. Můžete tuto hlavičku kontrolovat takto:

# Stáhne jen hlavičky a kontroluje stavový kód
status_code=$(curl -I -s -o headers.txt -w "%{http_code}" "https://www.freeprivacypolicy.com/public/cookie-consent/4.0.0/cookie-consent.js")

# Kontrola, zda je status code 303
if [ "$status_code" -eq 303 ]; then
    echo "Hlavička 303 - soubor by měl být přesměrován."
else
    echo "Status code je $status_code, není potřeba přesměrování."
fi
 

4. Ukládání cookies pro další požadavky

Pro práci s cookies a jejich uchování mezi požadavky můžete použít curl s volbami -c a -b:

 # Uloží cookies do souboru cookies.txt
curl -c cookies.txt -D headers.txt -o index.html "https://zp....cz/"

# Při dalším požadavku načte cookies ze souboru cookies.txt
curl -b cookies.txt -D headers2.txt -o další_soubor.js "https://zp....cz/něco"

Vše v jednom skriptu

#!/bin/bash

# URL serveru
DOMAIN_1="zp..cz"

DOMAIN_2="www.freeprivacypolicy.com"

BASE_URL="https://$DOMAIN_1"
JS_URL="https://$DOMAIN_2/public/cookie-consent/4.0.0/cookie-consent.js"

# Soubor, do kterého se uloží cookies
COOKIE_FILE="cookies.txt"
# Soubor, do kterého se uloží hlavičky
HEADERS_FILE_1="headers_1.txt"
HEADERS_FILE_2="headers_2.txt"
HEADERS_FILE_3="headers_3.txt"
# Soubor pro JS
JS_FILE="file.js"

# První požadavek - stáhnutí HTML a uložení hlaviček
curl -s -c "$COOKIE_FILE" -D "$HEADERS_FILE_1" \
  -H "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/png,image/svg+xml,*/*;q=0.8" \
  -H "Accept-Encoding: gzip, deflate, br, zstd" \
  -H "Accept-Language: cs,sk;q=0.8,en-US;q=0.5,en;q=0.3" \
  -H "Connection: keep-alive" \
  -H "DNT: 1" \
  -H "Host: $DOMAIN_1" \
  -H "Sec-Fetch-Dest: document" \
  -H "Sec-Fetch-Mode: navigate" \
  -H "Sec-Fetch-Site: none" \
  -H "Sec-Fetch-User: ?1" \
  -H "Upgrade-Insecure-Requests: 1" \
  -H "User-Agent: Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:130.0) Gecko/20100101 Firefox/130.0" \
  "$BASE_URL/"

# Kontrola, zda soubor JS již existuje
if [ -f "$JS_FILE" ]; then
    echo "Soubor $JS_FILE již existuje, nestahuje se znovu."
else
    echo "Soubor $JS_FILE neexistuje, stahuje se nyní."

    # Získání hlavičky a status kódu pro kontrolu 303
    status_code=$(curl -I -s -b "$COOKIE_FILE" -o "$HEADERS_FILE_2" -w "%{http_code}" \
      -H "Accept: */*" \
      -H "Accept-Encoding: gzip, deflate, br, zstd" \
      -H "Accept-Language: cs,sk;q=0.8,en-US;q=0.5,en;q=0.3" \
      -H "Connection: keep-alive" \
      -H "DNT: 1" \
      -H "Host: $DOMAIN_2" \
      -H "Referer: $BASE_URL/" \
      -H "Sec-Fetch-Dest: script" \
      -H "Sec-Fetch-Mode: no-cors" \
      -H "Sec-Fetch-Site: cross-site" \
      -H "User-Agent: Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:130.0) Gecko/20100101 Firefox/130.0" \
      "$JS_URL")

    # Kontrola status kódu
    if [ "$status_code" -eq 303 ]; then
        echo "Přesměrování 303 - kontrolujte novou lokaci."
        # Případně můžete extrahovat hlavičku Location pro přesměrování
        new_location=$(grep -i "Location:" "$HEADERS_FILE_3" | awk '{print $2}')
        echo "Nová lokace je: $new_location"
        # Stáhnutí JS z nové lokace
        curl -s -b "$COOKIE_FILE" -o "$JS_FILE" "$new_location"
    else
        # Stáhnutí JS souboru, pokud není přesměrování
        curl -s -b "$COOKIE_FILE" -o "$JS_FILE" "$JS_URL"
        echo "JS soubor stažen do $JS_FILE"
    fi
fi

Parametr -s v příkazu curl znamená "silent mode" (tichý režim). Tento režim způsobí, že curl nebude zobrazovat žádné informace o průběhu stahování, jako je například ukazatel postupu, chyby nebo informace o připojení. Tento režim je užitečný, když chcete minimalizovat výstup příkazu curl, například když pracujete se skripty a potřebujete pouze data, nikoli průběžné informace.

V kontextu tvého kódu:

• curl -s -c "$COOKIE_FILE" znamená, že curl stáhne data (v tichém režimu) a uloží cookies do souboru "$COOKIE_FILE".
• curl -s -b "$COOKIE_FILE" znamená, že curl stáhne data (v tichém režimu) a při tom odešle cookies uložené v souboru "$COOKIE_FILE" na server.

Pokud chceš z curl dostat více informací pro ladění, můžeš vynechat parametr -s nebo použít -v (verbose) pro více podrobný výstup.

Parametr -I v příkazu curl znamená HEAD request. Tímto příkazem nepožaduješ kompletní obsah stránky nebo souboru, ale pouze hlavičky HTTP odpovědi.

V tomto kontextu:

• curl -I pošle požadavek na server pouze pro získání hlaviček a ne stáhne celé tělo odpovědi.
• -s je volba pro tichý režim, aby se nezobrazovaly průběžné zprávy nebo chyby.
• -b "$COOKIE_FILE" znamená, že curl při odesílání požadavku pošle uložené cookies z tohoto souboru.
• -o "$HEADERS_FILE" uloží hlavičky odpovědi do souboru.
• -w "%{http_code}" vypíše status kód HTTP odpovědi (například 200, 303, atd.).

Tímto způsobem můžeš získat pouze hlavičky, včetně status kódu, který lze zkontrolovat pro případy jako je přesměrování (status kód 303).

 

curl: stahování dokumentů a porozumění hlavičkám požadavků a odpovědí

Potřeboval jsem ujasnit některé hlavičky a jak funguje komunikace mezi serverem který chci navštívit a serverem ze kterého stahuji externí soubor s javaskriptem. Druhý server spravuje dokumenty v rámci politiky GDPR aj. Klíčové slovo je zde referer, které se jeví jako důležité pro to, aby server neodmítnul komunikaci (respektive, aby neodmítnul vydat ten soubor). Nicméně je ještě třeba zmínit, že když ten soubor s JS už je stažený, není třeba ho znovu stahovat, takže tam má potom být hlavička 303...

Takže navštívil jsem stránku a zkopíroval jednotlivé hlavičky. Při potvrzení Souhlasím nebo Odmítám jsem neviděl žádnou další hlavičku. Ale to je zvláštní, protože na Windows XP když jsem to zkoušel, tak se tam jedna hlavička se objevila.

Dotaz na ChatGPT 4o

Vysvětlete některé hlavičky při prohlížení stránky:
Zajímají mě tyto:
"Referer: https://zpo....cz/
Sec-Fetch-Dest: document
Sec-Fetch-Mode: navigate
Sec-Fetch-Site: none
Sec-Fetch-User: ?1
Sec-GPC: 1
Upgrade-Insecure-Requests: 1
"
a tyto "Referer: https://zpo....cz/
Sec-Fetch-Dest: script
Sec-Fetch-Mode: no-cors
Sec-Fetch-Site: cross-site
Sec-GPC: 1
"
což jsou dvě části z hlaviček požadavku. Co proběhlo celá ta komunikace hlaviček a stažení je tady:
1. STAŽEN Dokument HTML, stav 200, metoda GET, soubor /, html,
Hlavičky:

{
    "GET": {
        "scheme": "https",
        "host": "zpo....cz",
        "filename": "/",
        "remote": {
            "Adresa": "81.95.107.207:443"
        }
    }
}

Stav: 200 OK
Verze: HTTP/1.1
Přeneseno: 55,21 kB (velikost 54,84 kB)
Priorita požadavku: Highest
Překlad DNS: Systémové

HLAVIČKY ODPOVĚDI:
    
Cache-Control: no-cache
Content-Length:    54844
Content-Type: text/html
Date: Thu, 12 Sep 2024 10:51:14 GMT
Expires: Thu, 12 Sep 2024 10:51:14 GMT
Pragma: No-cache
Server: Microsoft-IIS/8.5
Set-Cookie: PHPSESSID=nokab95nldik6n67k2i9rmq9p3; path=/
Set-Cookie: kdojeto=731244171; expires=Wed, 25-Dec-2024 14:51:14 GMT
X-Powered-By: PHP/5.2.6
X-Powered-By: ASP.NET

+HLAVIČKY POŽADAVKU:

Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/png,image/svg+xml,*/*;q=0.8
Accept-Encoding: gzip, deflate, br, zstd
Accept-Language: cs,sk;q=0.8,en-US;q=0.5,en;q=0.3
Connection: keep-alive
DNT: 1
Host: zpo....cz
Priority: u=0, i
Sec-Fetch-Dest: document
Sec-Fetch-Mode: navigate
Sec-Fetch-Site: none
Sec-Fetch-User: ?1
Sec-GPC: 1
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:130.0) Gecko/20100101 Firefox/130.0

*********************************************
2. STAŽEN SOUBOR JS ZE SERVERU www.freeprivavypolicy.com:
cookie-consent.js
(GET
    https://www.freeprivacypolicy.com/public/cookie-consent/4.0.0/cookie-consent.js)

Stav: 200
Verze: HTTP/2
Přeneseno 58,05 kB (velikost 208,40 kB)
Referrer Policy: strict-origin-when-cross-origin
Překlad DNS: Systémové

HLAVIČKY ODPOVĚDI:

Bez mezipaměti
2 požadavky
Přeneseno: 113,26 kB / 263,25 kB
Hotovo za 5,14 s
DOMContentLoaded: 1,72 s
load: 6,13 s
    
GET  https://www.freeprivacypolicy.com/public/cookie-consent/4.0.0/cookie-consent.js
Stav
200
Verze: HTTP/2
Přeneseno 58,05 kB (velikost 208,40 kB)
Referrer Policy:strict-origin-when-cross-origin
Překlad DNS: Systémové

HLAVIČKY ODPOVĚDI:
age: 36188
alt-svc: h3=":443"; ma=86400
cache-control: public, immutable, max-age=3600
cf-bgj: minify
cf-cache-status: HIT
cf-polished: origSize=208402
cf-ray: 8c1f575feb67901e-FRA
content-encoding: br
content-type: application/javascript
date: Thu, 12 Sep 2024 10:51:15 GMT
etag: W/"0c766f68f2fedb231ad3b2c8fdde350b"
expires: Thu, 12 Sep 2024 01:14:35 GMT
last-modified: Wed, 11 Sep 2024 23:14:35 GMT
nel: {"success_fraction":0,"report_to":"cf-nel","max_age":604800}
referrer-policy: strict-origin-when-cross-origin
report-to: {"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=8qrMazROYhJV%2FQtrNeG%2BwZ1rLIOcqNLftPDz9D7M0okZcsjNwJK4lOJV9rE5sInPB4yg73vGSgppL932uLhxwUiVDYKU5KsHGcQMfGm73DJb07%2BhnI5KjarBMDwrJKJFGrL1MXGfPxsOfzM%3D"}],"group":"cf-nel","max_age":604800}
server: cloudflare
vary: Accept-Encoding
x-content-type-options: nosniff
X-Firefox-Spdy: h2
x-frame-options: SAMEORIGIN
x-priority: 5/n
x-xss-protection: 1; mode=block
x-z: 5179
    
+HLAVIČKY POŽADAVKU:
Accept: */*
Accept-Encoding: gzip, deflate, br, zstd
Accept-Language: cs,sk;q=0.8,en-US;q=0.5,en;q=0.3
Connection: keep-alive
DNT: 1
Host: www.freeprivacypolicy.com
Priority: u=2
Referer: https://zpo....cz/
Sec-Fetch-Dest: script
Sec-Fetch-Mode: no-cors
Sec-Fetch-Site: cross-site
Sec-GPC: 1
User-Agent: Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:130.0) Gecko/20100101 Firefox/130.0

3. NÁSLEDUJE POTVRZENÍ TLAČÍTKA "SOUHLASÍM":
Nepřišla a nebyla odeslána další hlavička (linux).
Ale na Windows XP jo.

Odpověď: Vysvětlení dotazovaných parametrů hlavičky

V této komunikaci vidíte, jak probíhá výměna hlaviček mezi klientem (váš prohlížeč) a serverem během načítání různých zdrojů. Pojďme se podívat na jednotlivé hlavičky:

1. Referer: https://zpo...cz

• Referer specifikuje, odkud byl požadavek odeslán. Například při načítání cookie-consent.js souboru se uvádí, že referenční stránka je z zpo....cz. Server freeprivacypolicy.com tak ví, že požadavek pochází z jiné domény.

2. Sec-Fetch-Dest

• Tato hlavička určuje, jaký typ zdroje se načítá. Zde jsou příklady:
  • document: Hlavní dokument (HTML stránky).
  • script: Skript, například JavaScriptový soubor.

3. Sec-Fetch-Mode

• navigate: Označuje, že se jedná o klasickou navigaci na novou stránku, například při načítání HTML dokumentu.
  • no-cors: Umožňuje načítání zdrojů bez podpory CORS (Cross-Origin Resource Sharing), například skriptů z jiných domén, aniž by bylo nutné, aby server povolil zdroje přes Access-Control-Allow-Origin.

4. Sec-Fetch-Site

• Určuje, zda požadavek pochází z té samé stránky nebo z jiné domény:
  • none: Požadavek přišel z té samé domény (první případ).
  • cross-site: Požadavek přišel z jiné domény (příklad načítání JavaScriptu z freeprivacypolicy.com).

5. Sec-Fetch-User

• ?1: Tato hodnota značí, že požadavek byl vyvolán uživatelem (např. kliknutí na odkaz).

6. Sec-GPC: 1

• Tato hlavička značí nastavení tzv. Global Privacy Control. Hodnota 1 znamená, že uživatel preferuje soukromí, tedy například omezení sledování.

7. Upgrade-Insecure-Requests: 1

• Značí, že prohlížeč preferuje bezpečnou verzi požadavku (HTTPS) oproti nešifrované (HTTP).

8. Accept

• Specifikuje, jaké typy obsahu prohlížeč očekává. Například:
  • text/html: HTML dokument.
  • application/javascript: JavaScriptový soubor.
  • image/avif, image/webp: Typy obrázků.
  • image/svg+xml: SVG obrázek.

9. Accept-Encoding

• Určuje, jaké formy komprese prohlížeč podporuje. V tomto případě:
  • gzip, deflate, br, zstd jsou metody komprese, které prohlížeč podporuje pro zrychlení načítání.

10. DNT: 1

• Značí, že uživatel nechce být sledován (DNT = Do Not Track).

---

Shrnutí komunikace:

• Nejprve byl stažen hlavní HTML dokument z zpo....cz. Požadavek byl GET, prohlížeč požadoval HTML dokument a odpověď serveru byla 200 OK s odpovídajícími hlavičkami (např. Cache-Control: no-cache, což znamená, že stránka by neměla být uložena do mezipaměti).

• Následně prohlížeč stáhl JavaScriptový soubor cookie-consent.js z www.freeprivacypolicy.com. Tento požadavek byl vyvolán jako cross-site (z jiné domény) s hlavičkou no-cors, což znamená, že pro tento skript nebyla nutná podpora CORS.

• Dále nastal problém při potvrzení tlačítka "Souhlasím", kdy na Linuxu nebyla odeslána nová hlavička, zatímco na Windows XP ano. To by mohlo být způsobeno rozdílným chováním prohlížeče nebo zabezpečením mezi těmito systémy.

Druhý dotaz na ChatGPT

"Referer: Referer specifikuje, odkud byl požadavek odeslán. Například při načítání cookie-consent.js souboru se uvádí, že referenční stránka je z zpo....cz. Server freeprivacypolicy.com tak ví, že požadavek pochází z jiné domény."
Nicméně já to chci podstrčit do curl ty hlavičky, abych až budu stahovat ten soubor s javascriptem freeprivacypolicy.com bral v potaz, že si prohlížím stránku zpo....cz - takže fakticky to neposílá server zpo....cz ale klient. Správně? slovo fetch v 2. Sec-Fetch-Dest a 3. Sec-Fetch-Mode spíš napovídá něco o způsobu zpracování (fetch) stránky. Upřesněte to. "cross-site: Požadavek přišel z jiné domény (příklad načítání JavaScriptu z freeprivacypolicy.com)."
Jak ale freeprivacypolicy.com může ověřit, že požadavek přišel z jiné domény, když si to v tom curl mohu přepsat tu hlavičku? Mohu ji zaměnit a změnit třeba server. Rozveďte smysl a účel cross-size a jak se používá. "Sec-Fetch-User

    ?1: Tato hodnota značí, že požadavek byl vyvolán uživatelem (např. kliknutí na odkaz)."
Jasně, to znamená, že i když v hlavičce je refererer, on si to stejně může modifikovat, takže server nemůže s jistotou určit zda to skutečně ten server zpo....cz žádá nebo ne.

"Accept-Encoding

    Určuje, jaké formy komprese prohlížeč podporuje. V tomto případě: gzip, deflate, br, zstd jsou metody komprese, které prohlížeč podporuje pro zrychlení načítání."
Když odešlu tuto hlavičku přes curl, nebude to pak problém? Nebo pokud by to curl nepodporoval tuto compresi, mám použít httpie jako náhradu?

Upřesňující odpověď

 

Ano, máte pravdu, že při použití nástroje jako je curl posílá hlavičky klient (váš počítač, skript, prohlížeč) a ne server, což vám dává možnost tyto hlavičky libovolně upravit.

Vysvětlení hlaviček:

1. Sec-Fetch-Dest: Tato hlavička označuje typ cíle, který je požadován (např. dokument, script, image). U Sec-Fetch-Dest: document jde o stahování HTML dokumentu, zatímco Sec-Fetch-Dest: script znamená, že se požaduje JavaScript soubor. Toto pomáhá serveru identifikovat typ požadovaného zdroje.

2. Sec-Fetch-Mode: Tato hlavička říká, jaký typ požadavku byl proveden. V případě navigate se jedná o požadavek na navigaci (např. kliknutí na odkaz nebo načtení stránky). no-cors znamená, že se jedná o požadavek, který nevyžaduje kontrolu CORS (Cross-Origin Resource Sharing), což se běžně používá pro externí zdroje jako JS soubory nebo obrázky.

3. cross-site (v rámci Sec-Fetch-Site): Tato hodnota hlavičky označuje, že požadavek pochází z jiné domény (například zpo....cz načítá soubor z freeprivacypolicy.com). Jak jste správně zmínil, server může jen těžko ověřit, zda skutečně požadavek pochází z jiné domény, protože Referer a další hlavičky může klient (vy) upravit. Servery mohou ověřit původ pomocí CORS politiky a kontrolovat, zda jsou oprávněné domény povoleny pro přístup ke zdrojům.

4. Sec-Fetch-User: Tato hlavička (?1) označuje, že požadavek byl vyvolán uživatelem, například kliknutím na odkaz. Server tak může reagovat jinak na požadavky uživatele než na automatizované požadavky.

Cross-site a jeho význam:

Cross-site požadavky jsou důležité z hlediska bezpečnosti a ochrany proti útokům, jako jsou CSRF (Cross-Site Request Forgery). Při cross-site požadavcích se server může rozhodnout, zda požadavek akceptuje na základě CORS pravidel. Když si hlavičky přepíšete v curlu, server to nepozná, ale pokud má striktní CORS politiku, může požadavek zamítnout.

Komprese a curl:

Co se týče komprese (gzip, deflate, br, zstd), curl podporuje většinu z těchto metod nativně. Pokud si nejste jistý, zda curl podporuje určitou metodu, můžete použít přepínač --compressed, který povolí curl přijmout komprimovaný obsah. Pokud by curl některou metodu nepodporoval, můžete zkusit jiný nástroj, například httpie, který má uživatelsky přívětivější rozhraní a nativní podporu více formátů komprese.

Např.:

curl --compressed https://www.example.com

Je možná svévolná záměna referer v hlavičce?

"Servery mohou ověřit původ pomocí CORS politiky a kontrolovat, zda jsou oprávněné domény povoleny pro přístup ke zdrojům."

Jasně, ale teoreticky mohu stahovat soubory html ze serveru zpo....cz, zatímco refererer pro javascript změním na jinou stránku, která je také na freeprivacypolicy.com registrována, takže si tento server bude myslet, že je to pro jiný server. Napříkad. Samozřejmě by takové jednání bylo zbytečné, stačí tam nechat refererer zpo....cz

Ano, ale nemá smysl

V rámci CORS server skutečně kontroluje, odkud požadavek přichází, ale pokud přepíšete hlavičku Referer a změníte ji na jinou doménu, server (pokud má slabší nebo žádnou kontrolu) nebude schopen ověřit, zda požadavek skutečně pochází z dané domény. To znamená, že pokud změníte referer na doménu, kterou server považuje za legitimní (např. jinou stránku na freeprivacypolicy.com), server to nemusí odhalit.

Takové přepisování hlaviček by však obvykle nemělo praktický význam, jak jste zmínil. V případě, že byste chtěl přistupovat ke zdrojům z jiné domény, bude efektivnější použít skutečnou Referer hodnotu (například z zpo....cz), protože to lépe odpovídá skutečnému scénáři, kdy si prohlížíte danou stránku a ona načítá externí zdroje.

Pokud by server freeprivacypolicy.com používal CORS politiku, která povoluje pouze konkrétní domény (například pouze example.com), váš požadavek by byl odmítnut, pokud byste uvedli jiný referer než ten, který je povolený. Ale jak jste řekl, změna Referer na správnou hodnotu (v tomto případě zpo....cz) by byla jednodušší a přirozenější.

Referer Strict Origin Policy when Cross Origin

1. GET  https://www.freeprivacypolicy.com/public/cookie-consent/4.0.0/cookie-consent.js
 "Referrer Policy:strict-origin-when-cross-origin"
Co znamená tato hodnota? A podle čeho prohlížeč věděl, že zpo....cz má nastaveno tento "strict" mode: Referrer Policy: strict-origin-when-cross-origin ?

2.
Ještě tam je několik nejasných parametrů a hodnot, zejména nosniff a h2.

x-content-type-options: nosniff
X-Firefox-Spdy: h2
x-frame-options: SAMEORIGIN
x-priority: 5/n
x-xss-protection: 1; mode=block
x-z: 5179

Odpověď 

. Referrer Policy: strict-origin-when-cross-origin

Tato hodnota říká prohlížeči, jak nakládat s hlavičkou Referer, když uživatel přechází mezi různými stránkami nebo když se načítají zdroje z různých domén:

• strict-origin-when-cross-origin znamená, že pokud je požadavek na stejnou doménu (například na zpo....cz), hlavička Referer bude obsahovat plnou URL adresu.
• Pokud je ale požadavek na jinou doménu (cross-origin), pak Referer obsahuje pouze původ domény, tedy schéma a doménu (např. jen https://zpo....cz bez konkrétní cesty).

Jak to prohlížeč věděl?

Prohlížeč si nezávisle nevybírá Referrer-Policy. Webová stránka nebo server může tuto politiku nastavit, a to buď přímo v HTML, nebo prostřednictvím HTTP hlaviček. Prohlížeč pak tuto politiku dodržuje při odesílání požadavků, například když načítá zdroje z jiných serverů. Pokud stránka zpo....cz má tuto politiku nastavenou, prohlížeč podle toho upraví hlavičku Referer pro všechny cross-origin požadavky.

2. Další nejasné parametry

x-content-type-options: nosniff

Tato hlavička brání prohlížeči v „hádání“ typu obsahu souborů (content sniffing). Když je nastavena na nosniff, prohlížeč bude vždy respektovat typ obsahu uvedený v hlavičce Content-Type, a nebude se pokoušet odhadnout obsah na základě dat v souboru. To pomáhá předcházet určitým bezpečnostním rizikům, například spouštění škodlivých skriptů.

X-Firefox-Spdy: h2

Tato hlavička ukazuje, že prohlížeč (v tomto případě Firefox) použil protokol HTTP/2 (h2) pro tento požadavek. HTTP/2 je novější verze HTTP protokolu, která umožňuje efektivnější komunikaci mezi klientem a serverem (např. multiplexing, rychlejší načítání).

x-frame-options: SAMEORIGIN

Tato hlavička říká, že obsah stránky nesmí být vnořen do <iframe> nebo jiných rámců na stránkách jiných domén. SAMEORIGIN znamená, že pouze stránky ze stejné domény mohou vložit obsah do rámce. To pomáhá chránit před útoky, jako je „clickjacking“.

x-priority: 5/n

Tato hlavička obvykle udává, jakou prioritu má tento požadavek. V tomto případě je priorita nastavena na hodnotu 5/n, což může znamenat relativní důležitost požadavku při vyřizování ze strany serveru, ale její konkrétní význam závisí na implementaci serveru.

x-xss-protection: 1; mode=block

Tato hlavička zapíná vestavěnou ochranu proti XSS (Cross-Site Scripting) v prohlížeči. Když je nastavena na 1, prohlížeč bude chránit proti XSS útokům. Parametr mode=block říká prohlížeči, aby v případě detekce XSS místo vykreslení stránky zablokoval celý obsah.

x-z: 5179

Tato hlavička může být vlastní implementací serveru a nemusí mít standardní význam. Hodnota 5179 může být ID pro interní sledování nebo zpracování požadavků, které server používá.

Celkově tyto hlavičky poskytují zabezpečení a správu toho, jakým způsobem prohlížeč nakládá s daty a jak server zachází s požadavky.

Network Error Logging (nel)

Co znamená toto: nel: {"success_fraction":0,"report_to":"cf-nel","max_age":604800} report-to: {"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=8qrMazROYhJV%2FQtrNeG%2BwZ1rLIOcqNLftPDz9D7M0okZcsjNwJK4lOJV9rE5sInPB4yg73vGSgppL932uLhxwUiVDYKU5KsHGcQMfGm73DJb07%2BhnI5KjarBMDwrJKJFGrL1MXGfPxsOfzM%3D"}],"group":"cf-nel","max_age":604800}

Co je nel?

Tyto dvě hlavičky, nel a report-to, souvisejí s mechanismem pro detekci a hlášení chyb v síťových přenosech pomocí Network Error Logging (NEL). Jsou využívány převážně na straně klienta (prohlížeče) pro monitorování a odesílání zpráv o problémech v síťových připojeních.

1. nel hlavička (Network Error Logging)

Hlavička nel konfiguruje pravidla pro zaznamenávání síťových chyb.

Význam jednotlivých parametrů pro tento typ hlavičky:

• success_fraction: 0: Určuje procento úspěšných síťových přenosů, které se mají logovat (0 znamená, že úspěšné přenosy se nebudou hlásit). Tedy se budou hlásit pouze chyby.
• report_to: "cf-nel": Tímto se specifikuje, kam se mají zasílat reporty o síťových chybách. V tomto případě se mají odesílat na skupinu s názvem "cf-nel", což odkazuje na službu Cloudflare.
• max_age: 604800: Toto je doba platnosti politiky (v sekundách), po kterou budou tyto záznamy aktivní. 604800 sekund odpovídá jednomu týdnu.

2. report-to hlavička

Hlavička report-to definuje endpointy, kam mají být odeslány záznamy chyb.

Význam jednotlivých částí pro hlavčkureport-to:

• endpoints: Obsahuje seznam endpointů, na které se mají odesílat chybové reporty. Zde je pouze jeden endpoint na adrese "https://a.nel.cloudflare.com/report/v4?s=...", který je součástí služby Cloudflare.
• group: "cf-nel": Určuje název skupiny, do které tento endpoint patří. Tato skupina se shoduje s hodnotou v nel hlavičce, což znamená, že všechny chyby definované v nel budou zasílány na tuto adresu.
• max_age: 604800: Udává dobu (v sekundách), po kterou tato pravidla zůstávají v platnosti (týden).

Účel a fungování:

Tyto hlavičky umožňují poskytovatelům (např. Cloudflare) monitorovat problémy s připojením jejich uživatelů. Pokud dojde k chybě v síťovém přenosu (např. nedostupnost serveru, selhání DNS, timeouty), prohlížeč (nebo jiný klient) zaznamená tuto chybu a odešle zprávu na předem definovaný server (endpoint), který je specifikován v report-to hlavičce.

Tento mechanismus pomáhá poskytovatelům získat informace o problémech v síti a případně je řešit, aniž by uživatelé museli manuálně hlásit chyby.

Shrnutí:

• nel hlavička určuje, jaké typy síťových událostí mají být zaznamenávány a kam budou odesílány (v tomto případě pouze chyby).
• report-to hlavička definuje endpoint (v tomto případě Cloudflare), kam se chybové hlášky budou zasílat.

Obě hlavičky spolupracují, aby umožnily automatizované sledování síťových problémů na straně klienta a jejich hlášení na server.

Je Cloudflare placená služba?

Ano, Cloudflare je placená služba, ale nabízí také bezplatnou variantu s omezenými funkcemi. Poskytuje služby pro zlepšení výkonu, bezpečnosti a spolehlivosti webových stránek, včetně Content Delivery Network (CDN), ochrany proti DDoS útokům, DNS managementu, SSL certifikátů a dalších.

Plány Cloudflare:

1. Bezplatný plán:

   • CDN a caching.
   • Ochrana proti DDoS útokům na základní úrovni.
   • SSL certifikáty.
   • Omezený přístup k analytickým nástrojům.
   • Podpora HTTP/2 a další základní služby.

2. Placené plány:

   • Pro plán (od cca 20 USD měsíčně): Nabízí pokročilé bezpečnostní funkce, lepší výkon a podrobnější analýzy.
   • Business plán (od cca 200 USD měsíčně): Poskytuje vyšší úroveň zabezpečení a výkonu, včetně WAF (Web Application Firewall), prioritní podpory a pokročilých SSL certifikátů.
   • Enterprise plán (individuální cena): Nejkomplexnější funkce, určené pro velké organizace s náročnými požadavky na výkon a bezpečnost.

Každý plán má různé úrovně služeb, které se mohou lišit podle potřeb zákazníka, přičemž bezplatný plán je ideální pro menší webové stránky nebo osobní projekty, zatímco placené plány jsou vhodné pro komerční a velké weby.

 

 

python skript pro kontrolu souborů podle seznamu souborů

all_txt_files_list.txt:

all||slovíčka 1. cyklu.txt
|_|/media/filmy/Videa - Kytara/Lekce kytary/1) SLOVÍČKA NEZAHRNUTÁ DO EXTRAHOVANÝCH VAZEB.txt|1) VAZBY PODMĚTU PŘÍSUDKU S ADVERBEM.txt|/media/filmy/Videa - Kytara/Lekce kytary/srt-korektura/1) PŘIPRAVENO (KRÁTKÝ TEXT VÝŇATEK)
*|2|/media/filmy/Videa - Kytara/Lekce kytary/2) SLOVÍČKA NEZAHRNUTÁ DO EXTRAHOVANÝCH VAZEB.txt|2) VAZBY PODMĚTU PŘÍSUDKU S ADVERBEM.txt|/media/filmy/Videa - Kytara/Lekce kytary/srt-korektura/2) PŘIPRAVENO (KRÁTKÝ TEXT VÝŇATEK)
+|3|/media/filmy/Videa - Kytara/Lekce kytary/3) SLOVÍČKA NEZAHRNUTÁ DO EXTRAHOVANÝCH VAZEB.txt|3) VAZBY PODMĚTU PŘÍSUDKU S ADVERBEM.txt|/media/filmy/Videa - Kytara/Lekce kytary/srt-korektura/3) PŘIPRAVENO (KRÁTKÝ TEXT VÝŇATEK)
^|4|/media/filmy/Videa - Kytara/Lekce kytary/4) SLOVÍČKA NEZAHRNUTÁ DO EXTRAHOVANÝCH VAZEB.txt|4) VAZBY PODMĚTU PŘÍSUDKU S ADVERBEM.txt|/media/filmy/Videa - Kytara/Lekce kytary/srt-korektura/4) PŘIPRAVENO (KRÁTKÝ TEXT VÝŇATEK)
&|5|/media/filmy/Videa - Kytara/Lekce kytary/5) SLOVÍČKA NEZAHRNUTÁ DO EXTRAHOVANÝCH VAZEB.txt|5) VAZBY PODMĚTU PŘÍSUDKU S ADVERBEM.txt|/media/filmy/Videa - Kytara/Lekce kytary/srt-korektura/5) PŘIPRAVENO (KRÁTKÝ TEXT VÝŇATEK)
$|6a,6b|/media/filmy/Videa - Kytara/Lekce kytary/6) SLOVÍČKA NEZAHRNUTÁ DO EXTRAHOVANÝCH VAZEB.txt|6) VAZBY PODMĚTU PŘÍSUDKU S ADVERBEM.txt|/media/filmy/Videa - Kytara/Lekce kytary/srt-korektura/6) PŘIPRAVENO (KRÁTKÝ TEXT VÝŇATEK - ROMANZA)
%|7|/media/filmy/Videa - Kytara/Lekce kytary/7) SLOVÍČKA NEZAHRNUTÁ DO EXTRAHOVANÝCH VAZEB.txt|7) VAZBY PODMĚTU PŘÍSUDKU S ADVERBEM.txt|/media/filmy/Videa - Kytara/Lekce kytary/srt-korektura/7) PŘIPRAVENO (KRÁTKÝ TEXT VÝŇATEK - LIGAR tocando)
@|8|/media/filmy/Videa - Kytara/Tipy-Tutorialy ke kytaře/1) SLOVÍČKA NEZAHRNUTÁ DO EXTRAHOVANÝCH VAZEB.txt|1) VAZBY PODNĚTU PŘÍSUDKU S ADVERBEM.txt|/media/filmy/Videa - Kytara/Tipy-Tutorialy ke kytaře/srt-korektura/1) PŘIPRAVENO (KRÁTKÝ TEXT - VÝŇATEK - 5 cosas que NO debes) .srt
#|9|/media/filmy/Videa - Kytara/Tipy-Tutorialy ke kytaře/2) SLOVÍČKA NEZAHRNUTÁ DO EXTRAHOVANÝCH VAZEB.txt|2) VAZBY PODNĚTU PŘÍSUDKU S ADVERBEM.txt|/media/filmy/Videa - Kytara/Tipy-Tutorialy ke kytaře/srt-korektura/2) PŘIPRAVENO (KRÁTKÝ TEXT - VÝŇATEK - 5 RASGUOS para TODO) .srt
*|0|/media/filmy/Videa - Kytara/Tipy-Tutorialy ke kytaře/3) SLOVÍČKA NEZAHRNUTÁ DO EXTRAHOVANÝCH VAZEB.txt|3) VAZBY PODNĚTU PŘÍSUDKU S ADVERBEM.txt|/media/filmy/Videa - Kytara/Tipy-Tutorialy ke kytaře/srt-korektura/3) PŘIPRAVENO (KRÁTKÝ TEXT - VÝŇATEK - 5 Técnicas PRO) .srt
°||/media/filmy/Videa - Kytara/Tipy-Tutorialy ke kytaře/4) SLOVÍČKA NEZAHRNUTÁ DO EXTRAHOVANÝCH VAZEB.txt|4) VAZBY PODNĚTU PŘÍSUDKU S ADVERBEM.txt|/media/filmy/Videa - Kytara/Tipy-Tutorialy ke kytaře/srt-korektura/4) PŘIPRAVENO (KRÁTKÝ TEXT - VÝŇATEK - CEJILLA - BARRÉ) .srt
||/media/filmy/Videa - Kytara/Tipy-Tutorialy ke kytaře/5) SLOVÍČKA NEZAHRNUTÁ DO VAZEB AI.txt||
!||/media/filmy/Videa - Kytara/Těžší vyučování bez praxe/SLOVÍČKA NEZAHRNUTÁ DO EXTRAHOVANÝCH VAZEB.txt|VAZBY PODNĚTU PŘÍSUDKU S ADVERBEM - La armonia en el Flamenco.txt|/media/filmy/Videa - Kytara/Těžší vyučování bez praxe/srt-korektura/PŘIPRAVENO (KRÁTKÝ TEXT - VÝŇATEK - HARMONIE FLAMENKA).txt

Skript:

import re
import os
import time

# Cíl adresářové struktury
target_directory = "/media/filmy/výuka-španělštiny"
log_file = "report.log"
specChars = "_!@#$%^&*°<>/0123456789" # Speciální znak, které se mohou objevit na začátku řádku se slovní zásobou

# Čtení souboru all_txt_files.list.txt
with open("all_txt_files.list.txt", "r") as file:
    lines = file.readlines()

def get_prefix(line):
    # Regulární výraz pro nalezení prefixu s písmenem
    match = re.match(r'^([_!@#$%^&*°<>/0123456789]*[\p{L}])', line, re.UNICODE)
    if match:
        prefix = match.group(0)
        # Zjistit, zda za písmenem následují dva nebo více nespeciálních znaků
        pos = len(prefix)
        if pos < len(line):
            # Kontrola, zda následují dva nebo více nespeciálních znaků nebo konec řádku
            following_text = line[pos:]
            if len(following_text) > 1 and not any(c in specChars for c in following_text[:2]):
                return prefix
            if pos == len(line) or (len(following_text) > 0 and following_text[0] not in specChars):
                return prefix
    return ''

def log_message(current_file, message="", content=""):
    """Zapisuje zprávu do logu a zároveň ji vypisuje na obrazovku."""
    with open(log_file, "a") as log:
        if not content:
            log.write(f"{current_file}: {message}\n")
        else:
            log.write(f"{current_file}: {message}, content: \n{content}\n")
    if not current_file:
        print(f"{message}\n")
    else:
        print(f"{current_file}: {message}\n")

# Vrací tři proměnné z prvního řádku
def get_first_line(lines):
    first_line = lines[0].strip().split('|')
    if len(first_line) >= 3:
        var1 = first_line[0].strip()  # První hodnota
        var2 = first_line[1].strip()  # Druhá hodnota
        var3 = first_line[2].strip()  # Třetí hodnota
        return var1, var2, var3
    else:
        print("Chyba: První řádek nemá očekávaný formát.")
        exit(1)

def process_files_from_arrays(vazby_excluded_path_list, vazby_path_list, original_shorted_path_list):
    i = 0
    for path in vazby_excluded_path_list:
        process_file_content(path)
        if not vazby_path_list[i]:
            print(f"No file vazby_path='' when processing file {path}")
        else:
            process_file_content(vazby_path_list[i])

        if not original_shorted_path_list[i]:
            print(f"No file original_shorted_path='' when processing file {path}")
        else:
            process_file_content(original_shorted_path_list[i])
    i += 1

# Funkce pro ověření a přípravu polí
def verify_and_prepare_arrays(lines):
    prefix_compared_prev = []
    prefix_compared_cycle_1 = []
    vazby_path_list = []
    vazby_excluded_path_list = []
    original_shorted_path_list = []

    base_path = "/media/filmy/Videa - Kytara&Suno/"

    for index, line in enumerate(lines):
        columns = line.strip().split('|')
        print(f"LINE: {line}")
        # Zkontrolovat, zda je správný počet sloupců (mělo by být 5 sloupců)
        if len(columns) != 5:
            print(f"Chyba: nesprávný počet sloupců na řádku {index + 1}")
            exit(1)

        # Uložit hodnoty prvního sloupce do pole, pokud existují
        if columns[0]:
            prefix_compared_prev.append(columns[0].strip())

        # Uložit hodnoty druhého sloupce do pole, pokud existují
        if columns[1]:
            prefix_compared_cycle_1.append(columns[1].strip())

        # Ověřit existenci souboru ve třetím sloupci a uložit do pole
        vazby_excluded_path = columns[2].strip()
        expected_dir = os.path.dirname(vazby_excluded_path)
        if not os.path.isfile(vazby_excluded_path):
            print(f"Chyba: soubor neexistuje (třetí sloupec) {vazby_excluded_path} na řádku {index + 1}")
            exit(1)
        vazby_excluded_path_list.append(vazby_excluded_path)

        # Ověřit existenci souboru ve čtvrtém sloupci a uložit do pole
        vazby_path = columns[3].strip()
        if vazby_path:
            dir_name = os.path.dirname(vazby_path)
            # if dir_name is empty add base path
            if not dir_name: # from 3rd column  
                vazby_path = os.path.join(expected_dir, vazby_path)
                if not os.path.isfile(vazby_path):
                    print(f"Chyba: soubor neexistuje (čtvrtý sloupec)  dir_name: {dir_name}, {vazby_path} na řádku {index + 1}")
                    exit(1)
        vazby_path_list.append(vazby_path)

        # Pokud cesta existuje, ověřit existenci souboru v pátém sloupci a uložit do pole
        original_shorted_text_path = columns[4].strip()
        if original_shorted_text_path:
            if not os.path.isfile(original_shorted_text_path):
                print(f"Chyba: soubor neexistuje (pátý sloupec) {original_shorted_text_path} na řádku {index + 1}")
                exit(1)
        original_shorted_path_list.append(original_shorted_text_path)

    return (prefix_compared_prev, prefix_compared_cycle_1, vazby_path_list,
            vazby_excluded_path_list, original_shorted_path_list)

def process_file_content(file_path):
    # 14. Zpracovat soubor, filtrovat řádky, které obsahují dva velké znaky
    with open(file_path, "r") as f:
        content = f.readlines()
    is_line_comment = False
    is_vocabulary_header = False
    is_line_vocabulary = False
    starts_with_specChar = False
    prefix = False
    for line in content:
        # Identifikovat komentáře ve stylu KOMENTÁŘ
        if not (any(c.isupper() for c in line[:2]) and line[:2].isupper()):
          is_line_comment = True
        else:
          is_line_comment = False

        # 15. Zjistit, zda řádek obsahuje pipeline "|"
        if "|" in line:
            is_line_vocabulary = True
            first_word = line.split("|")[0].strip()
        else
            is_line_vocabulary = False
            first_word = ""

    # 16. Zjistit, zda řádek obsahuje závorky, pokud ano, zkrátit řádek
    stripped_line = line
    if not is_line_comment:
        if line:
           if line[0] in specChars:
              prefix ...

        if line.strip().endswith(":"):
            is_vocabulary_header = True
        else
            is_vocabulary_header = False

        if "(" in line:
            stripped_line = line.split("(")[0].strip()

    # 17. Zjistit, zda řádek obsahuje blok "///"
    block_is_found = False
    block_message = []  # Sběr textu bloku
    for line in filtered_content:
        if "///" in line:
            log_message(file_path, "Nový blok nalezen")
            block_message.append(line)
            block_is_found = True
            continue
        
        if block_is_found and any(c.isupper() for c in line[:2]) and line[:2].isupper():
            continue
        
        if block_is_found and not line.strip():
            log_message("", "Konec bloku nalezen", ''.join(block_message))
            block_is_found = False

    # 18. Zjistit a zpracovat text "NEZAHRNUT"
    if "NEZAHRNUT" in file_path:
        explanation_block = []
        in_explanation = False
        for line in filtered_content:
            if "Vysvětlení:" in line:
                in_explanation = True
            
            if in_explanation:
                explanation_block.append(line)
                if "opakuj" in line:
                    log_message(file_path, "Nalezen blok vysvětlení")
                elif not line.strip():  # Konec bloku vysvětlení
                    log_message(file_path, "Konec bloku vysvětlení", ''.join(explanation_block))
                    explanation_block = []
                    in_explanation = False

# Získání proměnných z prvního řádku
flag_cycle, var2, words_cycle_1_path = get_first_line(lines)
if not os.path.isfile(words_cycle_1_path):
    print(f"Chyba: soubor neexistuje {words_cycle_1_path}")
    exit(1)

# Odstraní první řádek poté co jsem ho zpracoval
lines = lines[1:]

# Příprava polí pomocí nové funkce
(prefix_compared_prev, prefix_compared_cycle_1, vazby_path_list,
 vazby_excluded_path_list, original_shorted_path_list) = verify_and_prepare_arrays(lines)
process_files_from_arrays(vazby_excluded_path_list, vazby_path_list, original_shorted_path_list)

# Ukončení zpracování
print("Všechny soubory byly zpracovány.")


Python: Skript na export segmentů videa a jejich zpomalení

Předchozí skript obsahoval vážnou chybu. Zvuk byl příliš opožděn za obrazem asi o 35% a ve výsledku se tam vešla jen 1/2 z původního segmentu. 

Nový skript vypadá dobře. Testováno jen pro zpomalení 8x.

# TENTO SKRIPT S librosou vypadá opravdu správně
# ALE TESTOVAL JSEM TO ZATÍM JEN NA 8X ZPOMALENÍ

# REQUIRES: moviepy, librosa, soundfile
import os
from moviepy.editor import VideoFileClip, concatenate_videoclips, vfx, AudioFileClip
import librosa
import soundfile as sf
import time

# Cesty ke složkám
home_dir = os.path.expanduser("~")
default_path = "/TUTORIALS"
input_dir = os.path.join("/media/toshiba/home/user/Videa", default_path)

file = 'TUTORIAL DRŽENÍ ZÁPĚSTÍ A PRSTY PRAVÉ RUKY -5 cosas que NO debes hacer tocando la guitarra.mp4'
input_path = os.path.join(input_dir, file)

ramdisk_disable = True  # Deaktivuje vytvoření RAM disku

user_choice = input("Chcete použít aktuální složku (.) nebo přednastavenou složku? Zadejte '.' pro aktuální složku nebo 'default' pro přednastavenou složku: ")
if user_choice == '.':
    input_dir = os.path.abspath('.')
    input_path = os.path.join(input_dir, file)

# Faktory zpomalení
# slowdowns = [2, 4, 6, 8, 10, 15, 20, 25]
slowdowns = [8]

# Vytvoření výstupních složek dynamicky na základě faktorů zpomalení
output_dirs = [os.path.join(input_dir, f"Output/{factor}") for factor in slowdowns]
for dir in output_dirs:
    os.makedirs(dir, exist_ok=True)

# Vytvoření RAM disku (bez skutečného připojení, pokud je ramdisk_disable = True)
ramdisk_path = os.path.join(input_dir, "ramdisk")
log_file = os.path.join(input_dir, "ramdisk.log")
if not os.path.exists(ramdisk_path):
    os.makedirs(ramdisk_path)

if not ramdisk_disable:
    with open(log_file, "w") as log:
        os.system(f'sudo mount -t tmpfs -o size={ramdisk_size}M tmpfs "{ramdisk_path}"')
        os.system(f'df "{ramdisk_path}" > "{log_file}"')

    with open(log_file, "r") as log:
        log_content = log.read()

    if ramdisk_path in log_content:
        print(f"RAM disk is correctly mounted.")
    else:
        print(f"RAM disk is not found")

# Funkce pro změnu pitchu pomocí ffmpeg
def audio_pitchup_ffmpeg(input_audio_path, output_audio_path, factor):
    command = f'ffmpeg -i "{input_audio_path}" -filter_complex "rubberband=pitch={factor}" "{output_audio_path}"'
    os.system(command)

# Funkce pro změnu rychlosti zvuku pomocí librosa
def change_audio_speed(input_audio_path, output_audio_path, speed_factor, target_duration):
    # Načtěte původní zvukový soubor
    y, sr = librosa.load(input_audio_path, sr=None)
    
    # Získejte a vytiskněte délku původního zvuku
    original_duration = librosa.get_duration(y=y, sr=sr)
    print(f"Audio duration before stretching: {original_duration} seconds")
    
    # Zrychlete/zpomalte zvuk tak, aby odpovídal nové délce videa
    y_stretched = librosa.effects.time_stretch(y, rate=original_duration / target_duration)
    
    # Získejte a vytiskněte délku zvuku po zpracování
    stretched_duration = librosa.get_duration(y=y_stretched, sr=sr)
    print(f"Audio duration after stretching: {stretched_duration} seconds")
    time.sleep(2)
    
    # Uložte zpracovaný zvuk do nového souboru
    sf.write(output_audio_path, y_stretched, sr)

# Převod času na sekundy
def convert_to_seconds(time_str):
    parts = time_str.split(':')
    minutes = int(parts[0])
    seconds = float(parts[1])
    return minutes * 60 + seconds

# Definice časových rozsahů k vyexportování
time_ranges = [
    ("0:0.0", "0:03.20")  # krátká ukázka základní techniky fingerpickingu když zpomalila
]

# Zpracování jednoho videa file
video_path = input_path
if os.path.isfile(video_path) and video_path.endswith(".mp4"):  # Upravte podle formátu vašich videí
    video_clip = VideoFileClip(video_path)
    
    # Exportování specifikovaných časových úseků jako dočasné soubory
    temp_clips = []
    for start_time, end_time in time_ranges:
        start_seconds = convert_to_seconds(start_time)
        end_seconds = convert_to_seconds(end_time)
        temp_clip = video_clip.subclip(start_seconds, end_seconds)
        temp_clips.append(temp_clip)
    
    # Sloučení úseků do jednoho videa
    temp_joined_path = os.path.join(input_dir, "temp_joined.avi")
    joined_clip = concatenate_videoclips(temp_clips)
    joined_clip.write_videofile(temp_joined_path, codec="libx264", audio_codec="aac")
    
    # Uzavření všech klipů
    for clip in temp_clips:
        clip.close()
    video_clip.close()
    joined_clip.close()
    
    # Zpomalení videí a korekce pitch v audio stopách
    for i, factor in enumerate(slowdowns):
        output_path = os.path.join(output_dirs[i], file)
        edited_clip = VideoFileClip(temp_joined_path)

        # Extrakce a úprava audio stopy
        temp_audio_path = os.path.join(ramdisk_path, "temp_audio.wav")
        edited_clip.audio.write_audiofile(temp_audio_path, codec='pcm_s16le')

        # Změna pitchu zvuku
        new_audio_path = os.path.join(ramdisk_path, "new_temp_audio.wav")
        audio_pitchup_ffmpeg(temp_audio_path, new_audio_path, factor)
        
        # Změna rychlosti upravené audio stopy tak, aby odpovídala nové délce videa
        final_audio_path = os.path.join(ramdisk_path, "final_audio.wav")
        change_audio_speed(new_audio_path, final_audio_path, factor, edited_clip.duration)
        
        new_audio_clip = AudioFileClip(final_audio_path)

        # Vytvoření nového video klipu s upravenou audio stopou
        edited_clip = edited_clip.set_audio(new_audio_clip)
        temp_video_name = os.path.join(ramdisk_path, "temp-final-video.m4a")
        edited_clip.write_videofile(
            temp_video_name,
            codec="libx264",
            audio_codec="aac",
            temp_audiofile=os.path.join(ramdisk_path, 'temp-audio-1.m4a'),
            remove_temp=True,
            threads=4,
            preset='ultrafast'
        )

        # Uzavření dočasných klipů
        edited_clip.close()
        new_audio_clip.close()

        # Znovu otevření video klipu pro zpomalení
        edited_clip = VideoFileClip(temp_video_name)
        edited_clip = edited_clip.fx(vfx.speedx, 1.0 / factor)
        edited_clip.set_duration(edited_clip.duration)

        print(f"Processing {file} with slowdown factor {factor}. Saving to {output_path}")
        edited_clip.write_videofile(
            output_path,
            codec="libx264",
            audio_codec="aac",
            temp_audiofile=os.path.join(ramdisk_path,'temp-audio-2.m4a'),
            remove_temp=True,
            threads=4,
            preset='ultrafast'
        )

        # Uzavření všech klipů
        edited_clip.close()

        # Odstranění dočasných souborů
        if os.path.exists(temp_audio_path):
            os.remove(temp_audio_path)
        if os.path.exists(new_audio_path):
            os.remove(new_audio_path)
        if os.path.exists(final_audio_path):
            os.remove(final_audio_path)
        if os.path.exists(temp_video_name):
            os.remove(temp_video_name)

    # Odstranění dočasného sloučeného videa
    if os.path.exists(temp_joined_path):
        os.remove(temp_joined_path)

print("Job done.")
if not ramdisk_disable:
    os.system(f'sudo umount "{ramdisk_path}"')