CoronaCountry entfernt

Verdoppelungsraten angepasst
master
Hofei90 5 years ago committed by Hofei90
parent 362ef48409
commit 813e3e5b42

@ -16,58 +16,18 @@ CONFIG = config_laden()
QUELLEN = ["jhu", "who", "rki"]
def alle_country_vereinheitlichen():
print("Betrete country vereinheitlichen")
country_dict = {}
for datensatz in db.CoronaCountry.select():
neuer_name = datensatz.country_region.lower().capitalize()
print(neuer_name)
try:
if neuer_name not in country_dict[datensatz.quelle]:
country_dict[datensatz.quelle].append(neuer_name)
except KeyError:
country_dict[datensatz.quelle] = [neuer_name]
with db.database.atomic() as transaction:
try:
db.CoronaDaten.update(country_region=neuer_name).where(
db.CoronaDaten.country_region == datensatz.country_region).execute()
print(neuer_name, datensatz.country_region)
except IntegrityError:
print("Fehler")
transaction.rollback()
print("Schleife Beendet")
db.CoronaCountry.delete().execute()
with db.database.atomic():
print("CountryCreate")
for quelle, countrys in country_dict.items():
print(quelle, countrys)
for country in countrys:
db.CoronaCountry.create(country_region=country, quelle=quelle)
def country_umbennnen():
quelle = input("Quelle eingeben: ")
name_altes_land = input("Name der alten Bezeichnung des Landes eingeben: ")
name_neues_land = input("Name der neuen Bezeichnung des Landes eingeben: ")
anzahl_daten = db.CoronaCountry.select().where(
(db.CoronaCountry.country_region == name_neues_land) & (db.CoronaCountry.quelle == quelle)
).count()
if anzahl_daten > 0:
db.CoronaCountry.delete().where(
db.CoronaCountry.country_region == name_altes_land
).execute()
else:
db.CoronaCountry.update(country_region=name_neues_land).where(
db.CoronaCountry.country_region == name_altes_land
).execute()
try:
db.CoronaDaten.update(country_region=name_neues_land).where(
db.CoronaDaten.country_region == name_altes_land
(db.CoronaDaten.country_region == name_altes_land) & (db.CoronaDaten.quelle == quelle)
).execute()
except IntegrityError:
db.CoronaDaten.delete().where(
db.CoronaDaten.country_region == name_altes_land
(db.CoronaDaten.country_region == name_altes_land) & (db.CoronaDaten.quelle == quelle)
).execute()

@ -12,14 +12,6 @@ class BaseModel(Model):
database = database
class CoronaCountry(BaseModel):
country_region = TextField(primary_key=True)
quelle = TextField(null=True)
class Meta:
table_name = 'corona_country'
class CoronaDaten(BaseModel):
active = IntegerField(null=True)
confirmed = IntegerField(null=True)
@ -37,8 +29,16 @@ class CoronaDaten(BaseModel):
primary_key = CompositeKey('country_region', 'ts')
class CoronaStatistik(BaseModel):
ts = DateTimeField()
quelle = TextField()
country_region = TextField()
typ = TextField()
wert = FloatField()
def create_tables():
database.create_tables([CoronaCountry, CoronaDaten])
database.create_tables([CoronaDaten])

@ -130,13 +130,6 @@ def daten_trennen(daten):
return daten_liste
def country_liste_erstellen(quelle, daten):
country_liste = []
for key in daten.keys():
country_liste.append(db.CoronaCountry(key, quelle))
return country_liste
def headers_erstellen():
headers = {"Authorization": "Bearer {token}".format(token=CONFIG["token"]),
"Prefer": "resolution=ignore-duplicates"}
@ -148,9 +141,7 @@ def main():
for quelle, url in QUELLEN.items():
json_daten = daten_abrufen(url)
daten = daten_erstellen(quelle, json_daten)
country_liste = country_liste_erstellen(quelle, daten)
daten_server = daten_trennen(daten)
db.sende_daten(CONFIG["url"], CONFIG["tablename_countryliste"], headers, country_liste)
db.sende_daten(CONFIG["url"], CONFIG["tablename_daten"], headers, daten_server)

@ -1,9 +1,10 @@
import toml
import os
import db_model as db
from peewee import SqliteDatabase
from peewee import fn
from peewee import PostgresqlDatabase
import datetime
from sshtunnel import SSHTunnelForwarder
import sys
def config_laden():
@ -29,26 +30,15 @@ def verdoppelungsrate_ermitteln(quelle, land, confirmed, confirmed_ts):
return verdoppelungstage
def letzte_verdopplungsrate(quelle, land):
query = db.CoronaDaten.select(db.CoronaDaten.ts, fn.max(db.CoronaDaten.confirmed).alias("confirmed")).where(
(db.CoronaDaten.quelle == quelle) & (db.CoronaDaten.country_region == land)).dicts()
for datensatz in query:
verdoppelung = verdoppelungsrate_ermitteln(quelle, land, datensatz["confirmed"], datensatz["ts"])
print(verdoppelung)
def durchschnittliche_verdoppelungsrate(quelle, land):
def letzte_verdopplungsraten(quelle, land, ts):
query = db.CoronaDaten.select(db.CoronaDaten.ts, db.CoronaDaten.confirmed).where(
(db.CoronaDaten.quelle == quelle) & (db.CoronaDaten.country_region == land)
).namedtuples()
verdoppelungsraten = []
(db.CoronaDaten.quelle == quelle) & (db.CoronaDaten.country_region == land) & (db.CoronaDaten.ts > ts)).dicts()
for datensatz in query:
verdoppelungsrate = verdoppelungsrate_ermitteln(quelle, land, datensatz.confirmed, datensatz.ts)
verdoppelungsrate = verdoppelungsrate_ermitteln(quelle, land, datensatz["confirmed"], datensatz["ts"])
if verdoppelungsrate is not None:
verdoppelungsraten.append(verdoppelungsrate)
durchschnitt = sum(verdoppelungsraten) / len(verdoppelungsraten)
print(verdoppelungsrate_in_tagen(durchschnitt))
verdoppelungsrate_tage = round(verdoppelungsrate_in_tagen(verdoppelungsrate), 3)
print(f"Verdoppelungsrate am {datensatz['ts']}: {verdoppelungsrate_tage}")
print("Verlasse letzte_Verdoppelungsraten")
def jede_verdoppelungsrate(quelle, land):
@ -57,7 +47,9 @@ def jede_verdoppelungsrate(quelle, land):
).order_by(db.CoronaDaten.ts.desc()).namedtuples()
for datensatz in query:
verdoppelungsrate = verdoppelungsrate_ermitteln(quelle, land, datensatz.confirmed, datensatz.ts)
print(f"Verdoppelungsrate am {datensatz.ts}: {verdoppelungsrate_in_tagen(verdoppelungsrate)}")
if verdoppelungsrate is not None:
verdoppelungsrate_tage = round(verdoppelungsrate_in_tagen(verdoppelungsrate), 3)
print(f"Verdoppelungsrate am {datensatz.ts}: {verdoppelungsrate_tage}")
def verdoppelungsrate_in_tagen(verdoppelungsrate):
@ -68,12 +60,25 @@ def verdoppelungsrate_in_tagen(verdoppelungsrate):
def main():
db.DATABASE.initialize(SqliteDatabase(os.path.join(SKRIPTPFAD, "corona.db3")))
for quelle in QUELLEN:
query = db.CoronaCountry.select().where(db.CoronaCountry.quelle == quelle)
for datensatz in query:
if quelle == "jhu" and datensatz.country_region == "Germany":
jede_verdoppelungsrate(quelle, datensatz.country_region)
with SSHTunnelForwarder(
(CONFIG["ssh"]["ip_server"], CONFIG["ssh"]["ssh_port"]), ssh_username=CONFIG["ssh"]["user"],
ssh_password=CONFIG["ssh"]["pw"], remote_bind_address=('127.0.0.1', CONFIG["pg"]["pgport"])) as server:
db.database.initialize(PostgresqlDatabase(CONFIG["pg"]["pgdb"],
user=CONFIG["pg"]["pguser"], password=CONFIG["pg"]["pgpw"],
host="127.0.0.1",
port=server.local_bind_port))
query_quelle = db.CoronaDaten.select(db.CoronaDaten.quelle).group_by(db.CoronaDaten.quelle)
for data in query_quelle:
query_country = db.CoronaDaten.select(
db.CoronaDaten.country_region).where(db.CoronaDaten.quelle == data.quelle
).group_by(db.CoronaDaten.country_region)
for datensatz in query_country:
if data.quelle == "jhu" and datensatz.country_region == "Germany":
letzte_verdopplungsraten(data.quelle, datensatz.country_region, datetime.datetime(2020, 4, 3))
print("Verlasse schleife")
sys.exit(0)
if __name__ == "__main__":

Loading…
Cancel
Save