CoronaCountry entfernt

Verdoppelungsraten angepasst

country_region_korrektur.py

@@ -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()
 
 

db_model.py

@@ -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])
 
 
 

scrape_corona.py

@@ -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)
 
 

verdoppelungsrate.py

@@ -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__":