chore: remove OrderedDict

Signed-off-by: Yves Bastide <yves@botify.com>

Author: ybastide

simpleflow/local/executor.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import collections
 import sys
 import traceback
 import uuid
@@ -27,8 +26,8 @@ def __init__(self, workflow_class, **kwargs):
         super().__init__(workflow_class)
         self.update_workflow_class()
         self.nb_activities = 0
-        self.signals_sent = set()
-        self._markers = collections.OrderedDict()
+        self.signals_sent: set[str] = set()
+        self._markers: dict[str, list[Marker]] = {}
 
         self.wf_run_id = []
         self.wf_id = []
@@ -206,7 +205,7 @@ def continue_as_new(self, workflow: type[Workflow], *args, **kwargs):
         self.update_workflow_class()
         self.nb_activities = 0
         self.signals_sent = set()
-        self._markers = collections.OrderedDict()
+        self._markers = {}
 
         self.wf_run_id = []
         self.wf_id = []

simpleflow/metrology.py

@@ -6,7 +6,6 @@
 import re
 import time
 from abc import ABC
-from collections import OrderedDict
 from typing import Any
 from urllib.parse import quote_plus
 
@@ -18,31 +17,29 @@
 
 
 class StepIO:
-    def __init__(self):
+    def __init__(self) -> None:
         self.bytes = 0
         self.records = 0
         self.sampled = False
 
-    def get_stats(self, time_total):
+    def get_stats(self, time_total: float) -> dict[str, Any]:
         mb_s = None
         rec_s = None
         if self.bytes:
             mb_s = round(float(self.bytes) / (1024 * 1024) / time_total, 2)
         if self.records:
             rec_s = int(self.records / time_total)
-        return OrderedDict(
-            [
-                ("bytes", self.bytes),
-                ("records", self.records),
-                ("mb_s", mb_s),
-                ("rec_s", rec_s),
-                ("sampled", self.sampled),
-            ]
-        )
+        return {
+            "bytes": self.bytes,
+            "records": self.records,
+            "mb_s": mb_s,
+            "rec_s": rec_s,
+            "sampled": self.sampled,
+        }
 
 
 class Step:
-    def __init__(self, name, task):
+    def __init__(self, name: str, task: MetrologyTask) -> None:
         self.name = name
         self.task = task
         self.read = StepIO()
@@ -57,22 +54,17 @@ def done(self):
         self.time_total = self.time_finished - self.time_started
 
     def get_stats(self):
-        stats = OrderedDict(
-            [
-                ("name", self.name),
-                ("metadata", self.metadata),
-                ("time_started", self.time_started),
-                ("time_finished", self.time_finished),
-                ("time_total", self.time_total),
-                ("read", self.read.get_stats(self.time_total)),
-                ("write", self.write.get_stats(self.time_total)),
-            ]
-        )
-        return stats
+        stats = {
+            "name": self.name,
+            "metadata": self.metadata,
+            "time_started": self.time_started,
+            "time_finished": self.time_finished,
+            "time_total": self.time_total,
+            "read": self.read.get_stats(self.time_total),
+            "write": self.write.get_stats(self.time_total),
+        }
 
-    def mset_metadata(self, kvs):
-        for k, v in kvs:
-            self.metadata[k] = v
+        return stats
 
 
 class StepExecution:
@@ -90,22 +82,22 @@ class MetrologyTask:
     context: dict[str, Any]
     steps: list[Step]
 
-    def can_upload(self):
+    def can_upload(self) -> bool:
         if not hasattr(self, "context"):
             return False
         return all(c in self.context for c in ("workflow_id", "run_id", "activity_id"))
 
     @property
     def metrology_path(self):
-        path = []
+        path: list[str] = []
         if settings.METROLOGY_PATH_PREFIX is not None:
             path.append(settings.METROLOGY_PATH_PREFIX)
         path.append(self.context["workflow_id"])
         path.append(quote_plus(self.context["run_id"]))
         path.append(f"activity.{self.context['activity_id']}.json")
         return str(os.path.join(*path))
 
-    def step(self, name):
+    def step(self, name: str) -> StepExecution:
         """
         To be called in a `with` execution
         Ex :

simpleflow/swf/mapper/models/base.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from collections import OrderedDict, namedtuple
+from collections import namedtuple
 
 from simpleflow.swf.mapper.core import ConnectedSWFObject
 from simpleflow.swf.mapper.exceptions import DoesNotExistError
@@ -13,15 +13,13 @@ class ModelDiff:
 
     :param  input: triples (tuples) storing in order: compared attribute name,
                    local model attribute value, upstream model attribute value.
-    :type   input: *args
 
     :param  ignore_fields: list of fields to ignore when comparing local and upstream
-    :type   ignore_fields: list
     """
 
-    def __init__(self, *input, ignore_fields: list[str] | None = None):
+    def __init__(self, *input: tuple[str, str, str], ignore_fields: list[str] | None = None):
         self.ignore_fields = ignore_fields or []
-        self.container: OrderedDict[str, tuple[str, str]] = self._process_input(input)
+        self.container: dict[str, tuple[str, str]] = self._process_input(input)
 
     def __contains__(self, attr):
         return attr in self.container
@@ -33,14 +31,14 @@ def __getitem__(self, index):
         attr, (local, upstream) = list(self.container.items())[index]
         return Difference(attr, local, upstream)
 
-    def _process_input(self, input):
-        return OrderedDict(
-            (attr, (local, upstream))
+    def _process_input(self, input: tuple[tuple[str, str, str], ...]) -> dict[str, tuple[str, str]]:
+        return {
+            attr: (local, upstream)
             for attr, local, upstream in input
             if local != upstream and attr not in self.ignore_fields
-        )
+        }
 
-    def add_input(self, *input):
+    def add_input(self, *input: tuple[str, str, str]):
         """Adds input differing data into ModelDiff instance"""
         self.container.update(self._process_input(input))