From c6d4e8b0f4a9295006236f8f50cac6bc3e0d00db Mon Sep 17 00:00:00 2001
From: Birte Kristina Friesel <birte.friesel@uos.de>
Date: Mon, 24 Mar 2025 14:08:25 +0100
Subject: Workload is an EventSequenceModel, actually

---
 bin/workload.py  |  4 +--
 lib/behaviour.py | 77 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 lib/workload.py  | 77 --------------------------------------------------------
 3 files changed, 79 insertions(+), 79 deletions(-)
 create mode 100644 lib/behaviour.py
 delete mode 100644 lib/workload.py

diff --git a/bin/workload.py b/bin/workload.py
index 5d71932..72b66bb 100755
--- a/bin/workload.py
+++ b/bin/workload.py
@@ -6,8 +6,8 @@ import logging
 import sys
 import dfatool.cli
 import dfatool.utils
+from dfatool.behaviour import EventSequenceModel
 from dfatool.model import AnalyticModel
-from dfatool.workload import Workload
 
 
 def main():
@@ -72,7 +72,7 @@ def main():
                 for attr in models[i].attributes(name):
                     print(f"    {name}.{attr}  {param_info(name, attr)}")
 
-    workload = Workload(models)
+    workload = EventSequenceModel(models)
     aggregate = workload.eval_strs(
         args.event,
         aggregate=args.aggregate,
diff --git a/lib/behaviour.py b/lib/behaviour.py
new file mode 100644
index 0000000..402ddc7
--- /dev/null
+++ b/lib/behaviour.py
@@ -0,0 +1,77 @@
+#!/usr/bin/env python3
+
+import logging
+from . import utils
+
+logger = logging.getLogger(__name__)
+
+
+class EventSequenceModel:
+    def __init__(self, models):
+        self.models = models
+
+    def _event_normalizer(self, event):
+        event_normalizer = lambda p: p
+        if "/" in event:
+            v1, v2 = event.split("/")
+            if utils.is_numeric(v1):
+                event = v2.strip()
+                event_normalizer = lambda p: utils.soft_cast_float(v1) / p
+            elif utils.is_numeric(v2):
+                event = v1.strip()
+                event_normalizer = lambda p: p / utils.soft_cast_float(v2)
+            else:
+                raise RuntimeError(f"Cannot parse '{event}'")
+        return event, event_normalizer
+
+    def eval_strs(self, events, aggregate="sum", aggregate_init=0, use_lut=False):
+        for event in events:
+            event, event_normalizer = self._event_normalizer(event)
+            nn, param = event.split("(")
+            name, action = nn.split(".")
+            param_model = None
+            ref_model = None
+
+            for model in self.models:
+                if name in model.names and action in model.attributes(name):
+                    ref_model = model
+                    if use_lut:
+                        param_model = model.get_param_lut(allow_none=True)
+                    else:
+                        param_model, param_info = model.get_fitted()
+                    break
+
+            if param_model is None:
+                raise RuntimeError(f"Did not find a model for {name}.{action}")
+
+            param = param.removesuffix(")")
+            if param == "":
+                param = dict()
+            else:
+                param = utils.parse_conf_str(param)
+
+            param_list = utils.param_dict_to_list(param, ref_model.parameters)
+
+            if not use_lut and not param_info(name, action).is_predictable(param_list):
+                logging.warning(
+                    f"Cannot predict {name}.{action}({param}), falling back to static model"
+                )
+
+            try:
+                event_output = event_normalizer(
+                    param_model(
+                        name,
+                        action,
+                        param=param_list,
+                    )
+                )
+            except KeyError:
+                logging.error(f"Cannot predict {name}.{action}({param}) from LUT model")
+                raise
+
+            if aggregate == "sum":
+                aggregate_init += event_output
+            else:
+                raise RuntimeError(f"Unknown aggregate type: {aggregate}")
+
+        return aggregate_init
diff --git a/lib/workload.py b/lib/workload.py
deleted file mode 100644
index 3e4f1f8..0000000
--- a/lib/workload.py
+++ /dev/null
@@ -1,77 +0,0 @@
-#!/usr/bin/env python3
-
-import logging
-from . import utils
-
-logger = logging.getLogger(__name__)
-
-
-class Workload:
-    def __init__(self, models):
-        self.models = models
-
-    def _event_normalizer(self, event):
-        event_normalizer = lambda p: p
-        if "/" in event:
-            v1, v2 = event.split("/")
-            if utils.is_numeric(v1):
-                event = v2.strip()
-                event_normalizer = lambda p: utils.soft_cast_float(v1) / p
-            elif utils.is_numeric(v2):
-                event = v1.strip()
-                event_normalizer = lambda p: p / utils.soft_cast_float(v2)
-            else:
-                raise RuntimeError(f"Cannot parse '{event}'")
-        return event, event_normalizer
-
-    def eval_strs(self, events, aggregate="sum", aggregate_init=0, use_lut=False):
-        for event in events:
-            event, event_normalizer = self._event_normalizer(event)
-            nn, param = event.split("(")
-            name, action = nn.split(".")
-            param_model = None
-            ref_model = None
-
-            for model in self.models:
-                if name in model.names and action in model.attributes(name):
-                    ref_model = model
-                    if use_lut:
-                        param_model = model.get_param_lut(allow_none=True)
-                    else:
-                        param_model, param_info = model.get_fitted()
-                    break
-
-            if param_model is None:
-                raise RuntimeError(f"Did not find a model for {name}.{action}")
-
-            param = param.removesuffix(")")
-            if param == "":
-                param = dict()
-            else:
-                param = utils.parse_conf_str(param)
-
-            param_list = utils.param_dict_to_list(param, ref_model.parameters)
-
-            if not use_lut and not param_info(name, action).is_predictable(param_list):
-                logging.warning(
-                    f"Cannot predict {name}.{action}({param}), falling back to static model"
-                )
-
-            try:
-                event_output = event_normalizer(
-                    param_model(
-                        name,
-                        action,
-                        param=param_list,
-                    )
-                )
-            except KeyError:
-                logging.error(f"Cannot predict {name}.{action}({param}) from LUT model")
-                raise
-
-            if aggregate == "sum":
-                aggregate_init += event_output
-            else:
-                raise RuntimeError(f"Unknown aggregate type: {aggregate}")
-
-        return aggregate_init
-- 
cgit v1.2.3