Das deutsche Python-Forum

Code: Alles auswählen

import sys
import requests

API_URL = "https://api.corona-zahlen.org/districts/"

DISTRICT = "berlin"

def get_json(url):
    response = requests.get(url)
    response.raise_for_status()
    return response.json()

def get_incidence(district_name):
    name = district_name.lower()
    data = get_json(API_URL)["data"]
    return {
        district["name"]: district["weekIncidence"]
        for district in data.values()
        if name in district["name"].lower()
    }

def main():
    district_name = sys.argv[1] if len(sys.argv) > 1 else DISTRICT
    result = get_incidence(district_name)
    if not result:
        print(f"Landkreis/Kreisstadt nicht gefunden")
    for name, incidence in result.items():
        print(f"{name}: {incidence:.01f}")

if __name__ == "__main__":
    main()

Code: Alles auswählen

#!/usr/bin/env python3

import sys
from urllib.parse import urljoin

import requests

API_URL = "https://api.corona-zahlen.org/districts/"

DISTRICT = "berlin"

def get_json(url):
    response = requests.get(url)
    response.raise_for_status()
    return response.json()

def get_district_records(district_key):
    key = str(district_key).lower()
    if key.isdigit():
        district_url = urljoin(API_URL, key)
        return get_json(district_url)["data"]
    data = get_json(API_URL)["data"]
    return {
        ags: dist for ags, dist in data.items()
        if key in dist["name"].lower()
    }

def get_info_lines(district_key):
    template = ("({ags}) {name}:\n{weekIncidence:.01f} Inzidenz, "
                "{cases} Gesamtfälle, {deaths} Verstorbene")
    result = get_district_records(district_key)
    return [template.format_map(dist) for dist in result.values()]

def main():
    district_key = sys.argv[1] if len(sys.argv) > 1 else DISTRICT
    lines = get_info_lines(district_key)
    if lines:
        print("\n\n".join(lines))
    else:
        print("Landkreis/Kreisstadt nicht gefunden")

if __name__ == "__main__":
    main()

Code: Alles auswählen

from collections import deque
from statistics import mean


def inzidenz_iter(daten, bewohner):
    """
    7-Tage inzidenz berechnen

    daten := Positiv getestet pro Tag

    Es wird der Mittelwert für 7 Tage auf 100_000 Einwohner ausgegeben.
    """

    def skalieren(wert):
        return wert * 100_000 / bewohner

    if len(daten) < 7:
        return ValueError("Zu wenig Daten")

    window = deque(daten[:7], maxlen=7)
    yield skalieren(mean(window))

    for value in daten[7:]:
        window.append(value)
        yield skalieren(mean(window))

Code: Alles auswählen

#!/usr/bin/env python3
import sys
import requests

API_URL = "https://api.corona-zahlen.org/districts/"

QUERY = "gelsen+essen+bochum"

def get_json(url):
    response = requests.get(url)
    response.raise_for_status()
    return response.json()

def get_district_records(query):
    terms = [term.strip().lower() for term in query.split("+")]
    data = get_json(API_URL)["data"]
    return {
        key: district for key, district in data.items()
        for term in terms if term in district["name"].lower()
    }

def get_info_text(query):
    template = ("{name}:\n{weekIncidence:.01f} Inzidenz, "
                "{cases} Gesamtfälle, {deaths} Verstorbene")
    districts = get_district_records(query).values()
    if not districts:
        raise ValueError("Landkreis/Kreisstadt nicht gefunden")
    return "\n\n".join(
        map(template.format_map, districts)
    )

def main():
    query = sys.argv[1] if len(sys.argv) > 1 else QUERY
    try:
        print(get_info_text(query))
    except Exception as error:
        print(error, file=sys.stderr)

if __name__ == "__main__":
    main()

Code: Alles auswählen

#!/usr/bin/env python3
import sys

import requests
from requests.exceptions import RequestException

from rich.console import Console
from rich.table import Table
from rich.text import Text

API_URL = "https://api.corona-zahlen.org/districts/"

QUERY = "berlin+hamburg+köln"

def _format_incidence(value):
    if value < 35:
        color = "bright_green"
    elif value < 50:
        color = "bright_yellow"
    elif value < 100:
        color = "orange3"
    else:
        color = "bright_red"
    return Text(f"{value:.01f}", color)

COLUMN_SPECS = {
    "Landkreis": ("name", str),
    "Inzidenz": ("weekIncidence", _format_incidence),
    "Gesamtfälle": ("cases", str),
    "Verstorbene": ("deaths", str),
}

def get_json(url):
    response = requests.get(url)
    response.raise_for_status()
    return response.json()

def get_district_records(query):
    terms = [term.strip().lower() for term in query.split("+")]
    data = get_json(API_URL)["data"]
    return {
        key: district for key, district in data.items()
        for term in terms if term in district["name"].lower()
    }

def get_table(query, specs=COLUMN_SPECS):
    districts = get_district_records(query).values()
    if not districts:
        raise ValueError(query)
    table = Table(*specs.keys())
    for district in districts:
        table.add_row(*(
            formatter(district[section])
            for section, formatter in specs.values()
        ))
    return table

_fail = sys.exit

def main():
    query = sys.argv[1] if len(sys.argv) > 1 else QUERY
    try:
        Console().print(get_table(query))
    except RequestException as error:
        _fail(f"Verbindung fehlgeschlagen: {error}")
    except ValueError as error:
        _fail(f"Keine Treffer: {error}")

if __name__ == "__main__":
    main()

Code: Alles auswählen

#!/usr/bin/env python3
import sys
from operator import itemgetter
from types import MappingProxyType

import requests
import rich
from requests.exceptions import RequestException
from rich.table import Table
from rich.text import Text

API_URL = "https://api.corona-zahlen.org/districts/"

QUERY = "berlin+hamburg+köln"


def _format_incidence(value):
    for limit, color in [
        (35, "bright_green"),
        (50, "bright_yellow"),
        (100, "orange3"),
    ]:
        if value < limit:
            break
    else:
        color = "bright_red"

    return Text(f"{value:.01f}", color)


COLUMN_SPECS = MappingProxyType(
    {
        "Landkreis": ("name", str),
        "Inzidenz": ("weekIncidence", _format_incidence),
        "Gesamtfälle": ("cases", str),
        "Verstorbene": ("deaths", str),
    }
)


def get_json(url):
    response = requests.get(url)
    response.raise_for_status()
    return response.json()


def get_district_records(query):
    terms = [term.strip().casefold() for term in query.split("+")]
    data = get_json(API_URL)["data"]
    return {
        key: district
        for key, district in data.items()
        for term in terms
        if term in district["name"].casefold()
    }


def get_table(query, specs=COLUMN_SPECS):
    districts = sorted(
        get_district_records(query).values(), key=itemgetter("name")
    )
    if not districts:
        raise ValueError(query)
    table = Table(*specs.keys())
    for district in districts:
        table.add_row(
            *(formatter(district[key]) for key, formatter in specs.values())
        )
    return table


_fail = sys.exit


def main():
    query = sys.argv[1] if len(sys.argv) > 1 else QUERY
    try:
        rich.print(get_table(query))
    except RequestException as error:
        _fail(f"Verbindung fehlgeschlagen: {error}")
    except ValueError as error:
        _fail(f"Keine Treffer: {error}")


if __name__ == "__main__":
    main()

Code: Alles auswählen

#!/usr/bin/env python3
import sys
from operator import itemgetter
from types import MappingProxyType
from functools import partial

import requests
import rich
from requests.exceptions import RequestException
from rich.table import Table
from rich.text import Text

API_URL = "https://api.corona-zahlen.org/districts/"

QUERY = "berlin+hamburg+köln"


def format_incidence(value):
    for limit, color in [
        (35, "bright_green"),
        (50, "bright_yellow"),
        (100, "orange3"),
    ]:
        if value < limit:
            break
    else:
        color = "bright_red"

    return Text(f"{value:.01f}", color)


def format_integer(value, sep, grouplen=3):
    s = str(int(value))
    if len(s) <= grouplen:
        return s
    offset = s.startswith("-") + (len(s) % grouplen)
    groups = [s[:offset]]
    groups.extend(
        s[i:(i + grouplen)] for i in
        range(offset, len(s), grouplen)
    )
    return sep.join(groups)


COLUMN_SPECS = MappingProxyType(
    {
        "Landkreis": ("name", str),
        "Inzidenz": ("weekIncidence", format_incidence),
        "Gesamtfälle": ("cases", partial(format_integer, sep=".")),
        "Verstorbene": ("deaths", partial(format_integer, sep=".")),
    }
)


def get_json(url):
    response = requests.get(url)
    response.raise_for_status()
    return response.json()


def get_district_records(query):
    terms = [term.strip().casefold() for term in query.split("+")]
    data = get_json(API_URL)["data"]
    return {
        key: district
        for key, district in data.items()
        for term in terms
        if term in district["name"].casefold()
    }


def get_table(query, specs=COLUMN_SPECS):
    districts = sorted(
        get_district_records(query).values(), key=itemgetter("name")
    )
    if not districts:
        raise ValueError(query)
    table = Table(*specs.keys())
    for district in districts:
        table.add_row(
            *(formatter(district[key]) for key, formatter in specs.values())
        )
    return table


_fail = sys.exit


def main():
    query = sys.argv[1] if len(sys.argv) > 1 else QUERY
    try:
        rich.print(get_table(query))
    except RequestException as error:
        _fail(f"Verbindung fehlgeschlagen: {error}")
    except ValueError as error:
        _fail(f"Keine Treffer: {error}")


if __name__ == "__main__":
    main()