Format with black

Author: tomalrussell

Diff for: src/smif/cli/__init__.py

@@ -7,111 +7,121 @@
 # Make profiling methods available through the logger
 def profiling_start(self, operation, key):
     time_placeholder = datetime.time(0, 0)
-    level = sum(log[1]['stop'] == time_placeholder for log in logging.Logger._profile.items())
+    level = sum(
+        log[1]["stop"] == time_placeholder for log in logging.Logger._profile.items()
+    )
     logging.Logger._profile[(operation, key)] = {
-        'start': datetime.datetime.now(),
-        'stop': time_placeholder,
-        'level': level
+        "start": datetime.datetime.now(),
+        "stop": time_placeholder,
+        "level": level,
     }
 
 
 def profiling_stop(self, operation, key):
-    logging.Logger._profile[(operation, key)]['stop'] = datetime.datetime.now()
+    logging.Logger._profile[(operation, key)]["stop"] = datetime.datetime.now()
 
 
 def summary(self, *args, **kws):
 
     if self.isEnabledFor(logging.INFO):
         summary = []
         columns = [30, 80, 12]
-        column = "{:" + str(columns[0]) + "s}" + \
-                 "{:" + str(columns[1]) + "s}" + \
-                 "{:" + str(columns[2]) + "s}"
-
-        level_width = max([profile['level'] for profile
-                          in logging.Logger._profile.values()]) * 2
+        column = (
+            "{:"
+            + str(columns[0])
+            + "s}"
+            + "{:"
+            + str(columns[1])
+            + "s}"
+            + "{:"
+            + str(columns[2])
+            + "s}"
+        )
+
+        level_width = (
+            max([profile["level"] for profile in logging.Logger._profile.values()]) * 2
+        )
         total_width = sum(columns) + level_width
 
         # header
-        summary.append(("{:*^" + str(total_width) + "s}").format(" Modelrun time profile "))
-        summary.append(column.format('Function', 'Operation', 'Duration [hh:mm:ss]'))
-        summary.append("*"*total_width)
+        summary.append(
+            ("{:*^" + str(total_width) + "s}").format(" Modelrun time profile ")
+        )
+        summary.append(column.format("Function", "Operation", "Duration [hh:mm:ss]"))
+        summary.append("*" * total_width)
 
         # body
         for profile in logging.Logger._profile.keys():
 
             # calculate time diff
             profile_data = logging.Logger._profile[profile]
-            diff = profile_data['stop'] - profile_data['start']
+            diff = profile_data["stop"] - profile_data["start"]
             s = diff.total_seconds()
-            time_spent = '{:02d}:{:02d}:{:05.2f}'.format(
-                int(s // 3600), int(s % 3600 // 60), s % 60)
+            time_spent = "{:02d}:{:02d}:{:05.2f}".format(
+                int(s // 3600), int(s % 3600 // 60), s % 60
+            )
 
             # trunctuate long lines
-            if len(profile[0]) > columns[0]-2:
-                func = profile[0][:columns[0]-3] + '..'
+            if len(profile[0]) > columns[0] - 2:
+                func = profile[0][: columns[0] - 3] + ".."
             else:
                 func = profile[0]
-            if len(profile[1]) > columns[1]-2:
-                op = profile[1][:columns[1]-3] + '..'
+            if len(profile[1]) > columns[1] - 2:
+                op = profile[1][: columns[1] - 3] + ".."
             else:
                 op = profile[1]
 
-            summary.append(profile_data['level']*'| ' + column.format(
-                func, op, time_spent))
+            summary.append(
+                profile_data["level"] * "| " + column.format(func, op, time_spent)
+            )
 
         # footer
-        summary.append("*"*total_width)
+        summary.append("*" * total_width)
 
         for entry in summary:
             self._log(logging.INFO, entry, args)
 
 
 def setup_logging(loglevel):
     config = {
-        'version': 1,
-        'formatters': {
-            'default': {
-                'format': '%(asctime)s %(name)-12s: %(levelname)-8s %(message)s'
+        "version": 1,
+        "formatters": {
+            "default": {
+                "format": "%(asctime)s %(name)-12s: %(levelname)-8s %(message)s"
             },
-            'message': {
-                'format': '\033[1;34m%(levelname)-8s\033[0m %(message)s'
-            }
+            "message": {"format": "\033[1;34m%(levelname)-8s\033[0m %(message)s"},
         },
-        'handlers': {
-            'file': {
-                'class': 'logging.FileHandler',
-                'level': 'DEBUG',
-                'formatter': 'default',
-                'filename': 'smif.log',
-                'mode': 'a',
-                'encoding': 'utf-8'
+        "handlers": {
+            "file": {
+                "class": "logging.FileHandler",
+                "level": "DEBUG",
+                "formatter": "default",
+                "filename": "smif.log",
+                "mode": "a",
+                "encoding": "utf-8",
+            },
+            "stream": {
+                "class": "logging.StreamHandler",
+                "formatter": "message",
+                "level": "DEBUG",
             },
-            'stream': {
-                'class': 'logging.StreamHandler',
-                'formatter': 'message',
-                'level': 'DEBUG'
-            }
-        },
-        'root': {
-            'handlers': ['file', 'stream'],
-            'level': 'DEBUG'
         },
+        "root": {"handlers": ["file", "stream"], "level": "DEBUG"},
         # disable_existing_loggers defaults to True, which causes problems with class/module
         # -specific loggers, especially in unit tests when this method might be called multiple
         # times
-        'disable_existing_loggers': False
+        "disable_existing_loggers": False,
     }
 
     if loglevel is None:
-        config['root']['level'] = logging.WARNING
+        config["root"]["level"] = logging.WARNING
     elif loglevel == 1:
-        config['root']['level'] = logging.INFO
+        config["root"]["level"] = logging.INFO
     else:
-        config['root']['level'] = logging.DEBUG
+        config["root"]["level"] = logging.DEBUG
 
     logging.config.dictConfig(config)
-    logging.debug('Debug logging enabled.')
+    logging.debug("Debug logging enabled.")
 
 
 logging.Logger.profiling_start = profiling_start

Diff for: src/smif/cli/log.py

@@ -37,13 +37,21 @@
 # import classes for access like ::
 #         from smif.controller import ModelRunner
 from smif.controller.execute_run import execute_model_run
-from smif.controller.execute_step import (execute_decision_step,
-                                          execute_model_before_step,
-                                          execute_model_step)
+from smif.controller.execute_step import (
+    execute_decision_step,
+    execute_model_before_step,
+    execute_model_step,
+)
 from smif.controller.modelrun import ModelRunner
 from smif.controller.setup import copy_project_folder
 
 # Define what should be imported as * ::
 #         from smif.controller import *
-__all__ = ['ModelRunner', 'execute_decision_step', 'execute_model_before_step',
-           'execute_model_run', 'execute_model_step', 'copy_project_folder']
+__all__ = [
+    "ModelRunner",
+    "execute_decision_step",
+    "execute_model_before_step",
+    "execute_model_run",
+    "execute_model_step",
+    "copy_project_folder",
+]

Diff for: src/smif/controller/__init__.py

@@ -29,25 +29,27 @@ def get_model_run_definition(store, modelrun):
         model_run_config = store.read_model_run(modelrun)
     except SmifDataNotFoundError:
         logging.error(
-            "Model run %s not found. Run 'smif list' to see available model runs.", modelrun)
+            "Model run %s not found. Run 'smif list' to see available model runs.",
+            modelrun,
+        )
         exit(-1)
 
-    logging.info("Running %s", model_run_config['name'])
+    logging.info("Running %s", model_run_config["name"])
     logging.debug("Model Run: %s", model_run_config)
-    sos_model_config = store.read_sos_model(model_run_config['sos_model'])
+    sos_model_config = store.read_sos_model(model_run_config["sos_model"])
 
-    sector_models = get_sector_models(sos_model_config['sector_models'], store)
+    sector_models = get_sector_models(sos_model_config["sector_models"], store)
     logging.debug("Sector models: %s", sector_models)
 
-    scenario_models = get_scenario_models(model_run_config['scenarios'], store)
+    scenario_models = get_scenario_models(model_run_config["scenarios"], store)
     logging.debug("Scenario models: %s", [model.name for model in scenario_models])
 
     sos_model = SosModel.from_dict(sos_model_config, sector_models + scenario_models)
-    model_run_config['sos_model'] = sos_model
+    model_run_config["sos_model"] = sos_model
     logging.debug("Model list: %s", list(model.name for model in sos_model.models))
 
-    model_run_config['strategies'] = store.read_strategies(model_run_config['name'])
-    logging.debug("Strategies: %s", [s['type'] for s in model_run_config['strategies']])
+    model_run_config["strategies"] = store.read_strategies(model_run_config["name"])
+    logging.debug("Strategies: %s", [s["type"] for s in model_run_config["strategies"]])
 
     return model_run_config
 
@@ -69,11 +71,11 @@ def get_scenario_models(scenarios, handler):
         scenario_definition = handler.read_scenario(scenario_name)
 
         # assign variant name to definition
-        scenario_definition['scenario'] = variant_name
+        scenario_definition["scenario"] = variant_name
 
         # rename provides => outputs
-        scenario_definition['outputs'] = scenario_definition['provides']
-        del scenario_definition['provides']
+        scenario_definition["outputs"] = scenario_definition["provides"]
+        del scenario_definition["provides"]
 
         logging.debug("Scenario definition: %s", scenario_name)
 
@@ -99,8 +101,8 @@ def get_sector_models(sector_model_names, handler):
         sector_model_config = handler.read_model(sector_model_name)
 
         # absolute path to be crystal clear for ModelLoader when loading python class
-        sector_model_config['path'] = os.path.normpath(
-            os.path.join(handler.model_base_folder, sector_model_config['path'])
+        sector_model_config["path"] = os.path.normpath(
+            os.path.join(handler.model_base_folder, sector_model_config["path"])
         )
         sector_model = SectorModel.from_dict(sector_model_config)
         sector_models.append(sector_model)
@@ -121,9 +123,9 @@ def build_model_run(model_run_config):
     """
     logger = logging.getLogger()
     try:
-        logger.profiling_start('build_model_run', model_run_config['name'])
+        logger.profiling_start("build_model_run", model_run_config["name"])
     except AttributeError:
-        logger.info('build_model_run %s', model_run_config['name'])
+        logger.info("build_model_run %s", model_run_config["name"])
 
     try:
         model_run = ModelRun.from_dict(model_run_config)
@@ -138,7 +140,7 @@ def build_model_run(model_run_config):
         exit(-1)
 
     try:
-        logger.profiling_stop('build_model_run', model_run_config['name'])
+        logger.profiling_stop("build_model_run", model_run_config["name"])
     except AttributeError:
-        logger.info('build_model_run %s', model_run_config['name'])
+        logger.info("build_model_run %s", model_run_config["name"])
     return model_run

Diff for: src/smif/controller/build.py

@@ -37,8 +37,12 @@ def execute_model_run(model_run_ids, store, warm=False, dry=False):
 
         try:
             if warm:
-                modelrun.run(store, job_scheduler, store.prepare_warm_start(modelrun.name),
-                             dry_run=dry)
+                modelrun.run(
+                    store,
+                    job_scheduler,
+                    store.prepare_warm_start(modelrun.name),
+                    dry_run=dry,
+                )
             else:
                 modelrun.run(store, job_scheduler, dry_run=dry)
         except SmifModelRunError as ex:

Diff for: src/smif/controller/execute_run.py

@@ -26,7 +26,9 @@ def execute_model_before_step(model_run_id, model_name, store, dry_run=False):
             model.before_model_run(data_handle)
 
 
-def execute_model_step(model_run_id, model_name, timestep, decision, store, dry_run=False):
+def execute_model_step(
+    model_run_id, model_name, timestep, decision, store, dry_run=False
+):
     """Runs a single step of a model run
 
     This method is designed to be the single place where smif actually calls wrapped models.
@@ -52,30 +54,36 @@ def execute_model_step(model_run_id, model_name, timestep, decision, store, dry_
     store: Store
     """
     if dry_run:
-        print("    smif step {} --model {} --timestep {} --decision {}".format(
-              model_run_id, model_name, timestep, decision))
+        print(
+            "    smif step {} --model {} --timestep {} --decision {}".format(
+                model_run_id, model_name, timestep, decision
+            )
+        )
     else:
         model, data_handle = _get_model_and_handle(
-            store, model_run_id, model_name, timestep, decision)
+            store, model_run_id, model_name, timestep, decision
+        )
         model.simulate(data_handle)
 
 
-def _get_model_and_handle(store, model_run_id, model_name, timestep=None, decision=None):
-    """Helper method to read model and set up appropriate data handle
-    """
+def _get_model_and_handle(
+    store, model_run_id, model_name, timestep=None, decision=None
+):
+    """Helper method to read model and set up appropriate data handle"""
     try:
         model_run_config = store.read_model_run(model_run_id)
     except SmifDataNotFoundError:
         logging.error(
             "Model run %s not found. Run 'smif list' to see available model runs.",
-            model_run_id)
+            model_run_id,
+        )
         sys.exit(1)
 
     loader = ModelLoader()
     sector_model_config = store.read_model(model_name)
     # absolute path to be crystal clear for ModelLoader when loading python class
-    sector_model_config['path'] = os.path.normpath(
-        os.path.join(store.model_base_folder, sector_model_config['path'])
+    sector_model_config["path"] = os.path.normpath(
+        os.path.join(store.model_base_folder, sector_model_config["path"])
     )
     model = loader.load(sector_model_config)
 
@@ -88,8 +96,8 @@ def _get_model_and_handle(store, model_run_id, model_name, timestep=None, decisi
         model=model,
         modelrun_name=model_run_id,
         current_timestep=timestep,
-        timesteps=model_run_config['timesteps'],
-        decision_iteration=decision
+        timesteps=model_run_config["timesteps"],
+        decision_iteration=decision,
     )
     return model, data_handle
 
@@ -117,20 +125,19 @@ def execute_decision_step(model_run_id, decision, store):
 
     # decision loop gets and saves decisions into "state" files
     decision_manager = DecisionManager(
-        store,
-        model_run['timesteps'],
-        model_run_id,
-        model_run['sos_model'],
-        decision
+        store, model_run["timesteps"], model_run_id, model_run["sos_model"], decision
     )
     bundle = next(decision_manager.decision_loop())
 
     # print report
     print("Got decision bundle")
-    print("    decision iterations", bundle['decision_iterations'])
-    print("    timesteps", bundle['timesteps'])
+    print("    decision iterations", bundle["decision_iterations"])
+    print("    timesteps", bundle["timesteps"])
     print("Run each model in order with commands like:")
-    print("    smif step {} --model <model> --decision <d> --timestep <t>".format(
-        model_run_id))
+    print(
+        "    smif step {} --model <model> --decision <d> --timestep <t>".format(
+            model_run_id
+        )
+    )
     print("To see a viable order, dry-run the whole model:")
     print("    smif run {} --dry-run".format(model_run_id))