refactor kontor-spring

kontor-scripts/import.py

@@ -4,7 +4,7 @@ import data from json file to PostgreSQL
 from argparse import ArgumentParser, ArgumentDefaultsHelpFormatter
 
 from datetime import datetime, date
-from typing import Any, AnyStr, Dict, List
+from typing import Any, Dict, List
 import os
 import json
 
@@ -43,7 +43,7 @@ def cleanup_database(db: Session, log, dry_run: bool):
                 db.delete(entry)
                 db.commit()
 
-def load_data(filename: str, log) -> Dict[AnyStr, Dict[AnyStr, Any]]:
+def load_data(filename: str, log) -> Dict[str, List[Dict[str, Any]]]:
     log.debug("load_data")
     import_file = Path(filename)
     if not import_file.exists():
@@ -54,13 +54,13 @@ def load_data(filename: str, log) -> Dict[AnyStr, Dict[AnyStr, Any]]:
         json_load = json.load(json_file)
     return json_load
 
-def get_ids(items: List[Any]) -> List[AnyStr]:
-    result: List[AnyStr] = []
+def get_ids(items: List[Any]) -> List[str]:
+    result: List[str] = []
     for item in items:
         result.append(item.id)
     return result
 
-def update_item(db: Session, import_data: Dict[AnyStr, Any], item: Any, dry_run: bool, log):
+def update_item(db: Session, import_data: Dict[str, Any], item: Any, dry_run: bool, log):
     for (key, value) in import_data.items():
         existing_value = getattr(item, str(key))
         update: bool = has_changed(existing_value, value, log)
@@ -76,7 +76,7 @@ def update_item(db: Session, import_data: Dict[AnyStr, Any], item: Any, dry_run:
                 db.add(item)
                 db.commit()
 
-def has_changed(existing_data: Any, import_data: AnyStr, log) -> bool:
+def has_changed(existing_data: Any, import_data: str, log) -> bool:
     if existing_data is None and import_data == 'None':
         return False
     if isinstance(existing_data, str):
@@ -94,7 +94,7 @@ def has_changed(existing_data: Any, import_data: AnyStr, log) -> bool:
     return existing_data != import_data
 
 
-def item_import(db: Session, import_data: Dict[AnyStr, Any], dry_run: bool, log):
+def item_import(db: Session, import_data: Dict[str, Any], dry_run: bool, log):
     log.info(f"import {import_data}")
     if not dry_run:
         log.debug(f"model: {repr(model)} {import_data}")
@@ -119,26 +119,27 @@ if __name__ == '__main__':
     with SessionLocal() as db:
         if args.cleanup:
             cleanup_database(db, logger, args.dry_run)
-        data = load_data(args.file, logger)
-        table_list: List = list(data.keys())
-        logger.info(f"Liste der Tabellen: {table_list}")
-        sorted_table_list: List = table_list
+        data: Dict[str, List[Dict[str, Any]]] = load_data(args.file, logger)
+        table_list: List[str] = list(data.keys())
+        logger.debug(f"Liste der Tabellen: {table_list}")
+        sorted_table_list: List[str] = table_list
         for tablename in sorted_table_list:
             model = registry[tablename]
             existing_items = db.query(model).all()
-            existing_ids = get_ids(existing_items)
+            existing_ids: List[str] = get_ids(existing_items)
             logger.debug(f"found {len(existing_items)} for table {tablename}")
-            import_items = data[tablename]
+            import_items: List[Dict[str, Any]] = data[tablename]
             for import_item in import_items:
-                if import_item['id'] in existing_ids:
-                    logger.debug(f"update {import_item['id']}")
-                    existing_item = db.get(model, import_item['id'])
+                item_id: str = import_item['id']
+                if item_id in existing_ids:
+                    logger.debug(f"update {item_id}")
+                    existing_item = db.get(model, item_id)
                     update_item(db, import_item, existing_item, args.dry_run, logger)
-                    existing_ids.remove(import_item['id'])
+                    existing_ids.remove(item_id)
                 else:
-                    logger.debug(f"import {import_item['id']}")
+                    logger.debug(f"import {item_id}")
                     item_import(db, import_item, args.dry_run, logger)
-            logger.info(f"remaining items for {tablename}: {len(existing_ids)}")
-            logger.info(f"remaining items for {tablename}: {existing_ids}")
+            logger.debug(f"remaining items for {tablename}: {len(existing_ids)}")
+            if len(existing_ids) > 0:
+                logger.info(f"remaining items for {tablename}: {existing_ids}")
     logger.info('kontor.import finished')
-