Vlákno názorů k článku Souběžné a paralelně běžící úlohy naprogramované v Pythonu (2) od johny - Python je fajn jazyk, ale na niektoré veci...

Python je fajn jazyk, ale na niektoré veci sa nehodí; trebárs na prácu s dátumami a časom či na konkurentné programovanie. Existuje tam veľa bugov a celé API je vo vývoji. Napr. populárny requests či Flask nepodporujú asynchrónne rutiny. Naozaj je jednoduchšie zvoliť si vhodnejší jazyk/platformu ako je F#, Go, Clojure, Groovy, Haskell či Erlang. (Fakt nechápem ľudí, ktorí idú oveľa náročnejšou cestou Python/GIL/C knižnice). Možno tak o 5-10 rokov to bude iné.

Asynchrónne rutiny ale už vyzerajú celkom k svetu.
Kombinácia asyncio a httpx:

#!/usr/bin/python

import httpx
import asyncio

async def get_async(url):
    async with httpx.AsyncClient() as client:
        return await client.get(url)

urls = ['http://webcode.me', 'https://httpbin.org/get',
    'https://google.com', 'https://stackoverflow.com',
    'https://github.com']

async def launch():
    resps = await asyncio.gather(*map(get_async, urls))
    data = [resp.status_code for resp in resps]

    for status_code in data:
        print(status_code)

asyncio.run(launch())

Ďalej tu máme vynikajúcu knižnicu Playwright; to je v podstate async
headless browser. Môžeme klikať, robiť screenshoty, vyplňovať
formuláre a pod.

#!/usr/bin/python

import asyncio
from playwright.async_api import async_playwright

async def run(playwright):

    chromium = playwright.chromium # or "firefox" or "webkit".
    browser = await chromium.launch()
    page = await browser.new_page()

    await page.goto("http://webcode.me")

    title = await page.title()
    print(title)

    await browser.close()

async def main():
    async with async_playwright() as playwright:
        await run(playwright)

asyncio.run(main())

Nevím, nakolik je ten Haskell jednodušší…

Souhlas, situace neni idealni. Existuje nekolik implementaci asynchronnich requests a asynchronni webove frameworky, ale treba django plne asynchronni zatim neni. Vetsinou masivni asynchronnost u backendu postavenem nad sql stejne nevyuzijete, bottlneck je databaze.

24. 3. 2022, 02:03 editováno autorem komentáře

"Python je fajn jazyk, ale na niektoré veci sa nehodí; trebárs na prácu s dátumami" - a to proč? Není to spíš vlastností knihovny a těch je pro práci s daty docela dost ve všech jazycích. Nebo jako že chybí built-in datový typ "timestamp"?

Protože ve standardní knihovně je to opravdu strašné, je tam hrozně moc typů a je to strašně rozlezlé. To vůbec nemluvím o časových pásmech, ale to se v posledních verzí hodně zlepšilo. Trochu mi to připomíná, jak to bylo v Java před verzí 8. Škoda, že tohle v Pythonu nedotáhnou, protože používat pro práci s datem externí knihovnu mi přijde divný.

Musite ignorovat starsi tutorialy a precist si novou oficialni dokumentaci, ktera neni spatna. Protoze asyncio vzniklo pred pridanim async/await syntaxe do pythonu, hodne se v poslednich verzich menilo. Novy tutorial uz je dobry.

To byl komentář k datumům v Python :-D. Ale souhlasím s vámi, že ty tutoriály jsou k asyncio často zastaralé.

Mimochodem, takovy format string pro data a casy v Go - to je aspon "novinka"

To je nuda, zajímavější je typově bezpečný formátovací řetězec pomocí GADT :)

No jo, no, "bateries included" tu moc nefunguje, ale Pendulum jede parádně.

Ako už bolo povedané, je to tam nesystematicky pomiešané v rôznych balíčkoch, plus si konkurujú viaceré externé knižnice. Ale ani jedna ani zďaleka nepostihuje dostatočne prácu s dátumami a časom.
Ide totiž o mimoriadne náročnú problematiku. Žiadna datetime knižnica nie je úplná. (Ono to je prakticky práca bez konca.)
Koľko je rôznych kalendárov! Niektoré krajiny mali alebo majú viaceré kalendáre...

Asi najviac prepracované to má standard JVM & Time4J. https://github.com/MenoData/Time4J

Ostatné platformy sú riadne pozadu. The right tool for the right job.

24. 3. 2022, 17:42 editováno autorem komentáře

A ešte nemôžem obísť F#. Najnovšia verzia vydaná teraz na jeseň
umožňuje elegantnú integráciu s .NET taskami.

open System.Net.Http
open System.Text.RegularExpressions
open System.Threading.Tasks

let fetchTitleAsync (url: string) =

    task {

        use client = new HttpClient()
        let! html = client.GetStringAsync(url)
        let pattern = "<title>\s*(.+?)\s*</title>"

        let m = Regex.Match(html, pattern)
        return m.Value
    }

let sites =
    [| "http://webcode.me"
       "http://example.com"
       "https://bing.com"
       "http://httpbin.org"
       "https://ifconfig.me"
       "http://termbin.com"
       "https://github.com" |]

let titles =
    sites
    |> Array.map fetchTitleAsync
    |> Task.WhenAll
    |> Async.AwaitTask
    |> Async.RunSynchronously

titles
|> Array.iter (fun title -> printfn $"%s{title}")

Async kód, computation expressions & custom DSL.

Príklad asynchrónne zadá do vyhľadávača heslo, klikne na selektovaný odkaz,
počká si na odpoveď a spraví screenshot. Plus si to všetko zabalíme do
elegantného DSLka.

Dokáže nejaký iný jazyk tomuto konkurovať?

#r "nuget: Microsoft.Playwright"

open Microsoft.Playwright
open System.Threading.Tasks

type PlaywrightBuilder() =

    member _.Yield _ =
        task {
            let! pw = Playwright.CreateAsync()
            let! browser = pw.Firefox.LaunchAsync(BrowserTypeLaunchOptions(Headless = true))
            return! browser.NewPageAsync()
        }

    [<CustomOperation "visit">]
    member _.Visit(page: Task<IPage>, url) =
        task {
            let! page = page
            let! _ = page.GotoAsync(url)
            return page
        }

    [<CustomOperation "screenshot">]
    member _.Screenshot(page: Task<IPage>, name) =
        task {
            let! page = page
            let! _ = page.ScreenshotAsync(PageScreenshotOptions(Path = $"{name}.png"))
            return page
        }

    [<CustomOperation "write">]
    member _.Write(page: Task<IPage>, selector, value) =
        task {
            let! page = page
            let! _ = page.FillAsync(selector, value)
            return page
        }

    [<CustomOperation "click">]
    member _.Click(page: Task<IPage>, selector) =
        task {
            let! page = page
            let! _ = page.ClickAsync(selector)
            return page
        }

    [<CustomOperation "wait">]
    member _.Wait(page: Task<IPage>, seconds) =
        task {
            let! page = page
            let! _ = page.WaitForTimeoutAsync(seconds)
            return page
        }

    [<CustomOperation "waitFor">]
    member _.WaitFor(page: Task<IPage>, selector) =
        task {
            let! page = page
            let! _ = page.WaitForSelectorAsync(selector)
            return page
        }

let playwright = PlaywrightBuilder()

playwright {
    visit "https://duckduckgo.com/"
    write "input" "root.cz"
    click "input[type='submit']"
    click "text=/Root\.cz/"
    waitFor "text=Root.cz - informace nejen ze světa Linuxu"
    screenshot "root"
}
|> Async.AwaitTask
|> Async.RunSynchronously

красота

"Dokáže nejaký iný jazyk tomuto konkurovať?"
Jasně dokáže, třeba Scala, která má lepší typový systém a dokonce je pod kapotou i jednodušší než F#. Problém F# je že to jsou vlastně dva jazyky slepené do jednoho. .NET runtime je objektový a tohle stále do F# někde probublává. Ale jinak žádná, je to na míle lepší než Python :D

Kromě Scaly možná OCaml?

Mozna i stary dobry ML, ktery jeste nebyl za...plnen OO-vecmi? :)

Scala má lepší typový systém než Java nebo C#, ale pořád poměrně slabý. V některých jazycích jde například mít funkci format, která pro vstup “Something: %s” vrátí funkci typu String -> String, pro “Something: %s %d” vrátí funkci typu String -> Int -> String atd. Tomu říkám typová bezpečnost :)

tohle dela i python (mypy), podle formatovaciho retezce overuje typ parametru funkce format

26. 3. 2022, 02:04 editováno autorem komentáře

A který jazyk to dělá takto jak píšeš?

@all

Mal som na mysli reálne, nie na papieri. :)

Teoreticky môžu konkurovať JS/TS, Go, Python, C#. Žiadny iný jazyk nemá knižnicu pre headless browsing. JVM jazyky majú, ale nepodporuje asynchrónne programovanie.

Tipoval by som, že najbližšie k tomu má Clojure. Zatiaľ do Clojure len fušujem, ale viem, že DSLko dokáže spraviť, predpokladám, že aj ekvivalent computational expressions. Ale žiaľ nemá podporu pre async Playwright.

(Add OOP. Scala nevie vypísať hello world bez toho, aby sme funkciu museli vopchať do objektu.)

Pro headless browsing je nejlepsi JS a puppeteer pripadne cypress.

To není pravda. Scala 3 má na míle lepší typový systém než F# a hello world taky zvládne.https://doc­s.scala-lang.org/scala3/bo­ok/taste-hello-world.html Nějaký další problém?

https://www.scala-lang.org/blog/2016/02/03/essence-of-scala.html

27. 3. 2022, 09:58 editováno autorem komentáře