Updated the play procedure to use the new models

playbook/__init__.py

@@ -6,7 +6,7 @@ from abc import ABC, abstractmethod
 from pydantic import BaseModel
 
 from playbook.models import ActModel, PlaybookModel, StepModel, timed_run
-from playbook.logging_models import Status, StepLogModel
+from playbook.logging_models import PlaybookLog, Status, StepLogModel
 from playbook.action_registry import ActionFn, ActionRegistry
 
 
@@ -21,61 +21,6 @@ class StepIF(ABC):
         """ Return a mapping of action roles (pre, play, post) to function names. """
         pass
 
-# class Play(object):
-#     def __init__(self, name: str, registries: dict[str, ActionRegistry]):
-#         self.name: str = name
-#         self.log_dir: str = ""
-#         self._context: dict[str, object] = {}
-#         self._acts: dict[str, list[CustomStep]] = {}
-#         self._steps: list[StepEntry] = []
-#         self._registries: dict[str, ActionRegistry] = {
-#             registry.name: registry} | registries
-#
-#
-#     def add_step(self, name: str, stepRunner: StepIF):
-#         self._steps.append(StepEntry(name=name, step=stepRunner))
-#
-#     def view_playbook(self) -> str:
-#         acts_info = {}
-#         for act_name, step_list in self._acts.items():
-#             steps_info = []
-#             for s in step_list:
-#                 steps_info.append({
-#                     "name": s.name,
-#                     "actions": s.get_action_names()
-#                 })
-#
-#             new_act = {
-#                 "name": act_name,
-#                 "steps": steps_info
-#             }
-#
-#             acts_info[act_name] = new_act
-#
-#         registry_data = []
-#         for reg in self._registries.values():
-#             registry_data.append(reg.manifest())
-#
-#         data = {
-#             "name": self.name,
-#             "registries": registry_data,
-#             "number_of_acts": len(acts_info),
-#             "acts": acts_info,
-#         }
-#
-#         return json.dumps(data)
-#
-#     def play(self) -> StepLogModel:
-#         log: StepLogModel = timed_run(self._play_act)
-#
-#         if self.log_dir != "":
-#             log.log_file_path = os.path.join(
-#                 self.log_dir, self.log_file_name(log.start_date_timestamp)
-#             )
-#             self._write_log(log)
-#
-#         return log
-#
 #     def log_file_name(self, start_date_ns: int) -> str:
 #         """ Format to ISO 8601. """
 #         seconds = start_date_ns // 1_000_000_000
@@ -212,7 +157,6 @@ class PlaybookYAMLParser():
         )
 
         return Playbook(new_playbook)
-    pass
 
 
 class Playbook():
@@ -232,5 +176,13 @@ class Playbook():
     def view_playbook(self) -> str:
         return self.model.model_dump_json()
 
-    def run_play(self):
+    def run_play(self) -> PlaybookLog:
-        return self.model.run()
+        log: PlaybookLog = self.model.run()
+
+        # if self.model.log_dir != "":
+        #     log.log_file_path = os.path.join(
+        #         self.model.log_dir, self.log_file_name(log.start_date_timestamp)
+        #     )
+        #     self._write_log(log)
+
+        return log

playbook/models.py

@@ -23,26 +23,26 @@ class StepModel(BaseModel):
     def serialize_action_fn(self, action_fn: ActionFn, _info) -> str:
         return getattr(action_fn, "__name__", str(action_fn))
 
-    def run(self, ctx) -> StepLogModel:
+    def run(self, ctx: dict[str, object]) -> StepLogModel:
         """ Run the step. """
         substeps: list[StepLogModel] = []
         previous_step_ctx: dict[str, object] = {}
-        for action in self.actions:
-            try:
-                local_ctx: CtxType = ctx | previous_step_ctx | self.context
-                log: StepLogModel = timed_run(
-                    action, local_ctx, self.name
-                )
-            except Exception as e:
-                log: StepLogModel = StepLogModel.fail(
-                    self.name, str(e)
-                )
 
-            previous_step_ctx = log.pipe_ctx
+        try:
+            local_ctx: CtxType = ctx | previous_step_ctx | self.context
+            log: StepLogModel = timed_run(
+                self.action, local_ctx, self.name
+            )
+        except Exception as e:
+            log: StepLogModel = StepLogModel.fail(
+                self.name, str(e)
+            )
 
-            substeps.append(log)
+        previous_step_ctx = log.pipe_ctx
-            if log.status == Status.BAD:
+
-                return StepLogModel.fail(self.name, err=f"failed on step: {log.name}")
+        substeps.append(log)
+        if log.status == Status.BAD:
+            return StepLogModel.fail(self.name, err=f"failed on step: {log.name}")
 
         return StepLogModel.ok(self.name, msg="success", substeps=substeps)
 
@@ -55,7 +55,7 @@ class ActModel(BaseModel):
     def run(self, ctx) -> ActLog:
         step_logs: list[StepLogModel] = []
         for step in self.steps:
-            stepLog: StepLogModel = step.run(ctx)
+            stepLog: StepLogModel = timed_run(step.run, ctx)
             step_logs.append(stepLog)
             if stepLog.failed:
                 break
@@ -101,7 +101,7 @@ class PlaybookModel(BaseModel):
     def _run(self) -> PlaybookLog:
         act_logs: list[ActLog] = []
         for act in self.acts:
-            log: ActLog = act.run(self.global_context)
+            log: ActLog = timed_run(act.run, self.global_context)
             act_logs.append(log)
 
         return PlaybookLog.ok(name="somasjd", msg="ajshdsajhd", logs=act_logs)