Add caching for decorator guard lookup and optimize step count calculation

- Introduce `_decorator_guard_cache` in `TestStep` to cache decorator guard lookups, improving performance.
- Add `_step_counts` to `OsmoHistory` for incremental step counting, reducing complexity in step statistics.

Author: OPpuolitaival

pyosmo/history/history.py

@@ -16,6 +16,8 @@ def __init__(self) -> None:
         self.test_cases: list[OsmoTestCaseRecord] = []
         self.stop_time: datetime | None = None
         self.start_time: datetime = datetime.now()
+        # Incremental step counter — avoids O(tc*s) history walks
+        self._step_counts: dict[str, int] = {}
 
     def start_new_test(self) -> None:
         # Stop test case timer
@@ -36,6 +38,7 @@ def add_step(self, step: TestStep, duration: timedelta, error: Exception | None
         if self.current_test_case is None:
             raise Exception('There is no active test case!!')
         self.current_test_case.add_step(TestStepLog(step, duration, error))
+        self._step_counts[step.name] = self._step_counts.get(step.name, 0) + 1
 
     def attach(self, name: str, data: str | bytes) -> None:
         """Attach data to the last step of the current test case."""
@@ -74,7 +77,7 @@ def is_used(self, step: TestStep) -> bool:
 
     def get_step_count(self, step: TestStep) -> int:
         """Counts how many times the step is really called during whole history"""
-        return sum(test_case.get_step_count(step) for test_case in self.test_cases)
+        return self._step_counts.get(step.name, 0)
 
     @property
     def step_stats(self) -> str:

pyosmo/model.py

@@ -34,6 +34,9 @@ def __str__(self) -> str:
         return f'{type(self.object_instance).__name__}.{self.function_name}()'
 
 
+_GUARD_NOT_CACHED = object()
+
+
 class TestStep(ModelFunction):
     def __init__(
         self,
@@ -47,6 +50,7 @@ def __init__(
         super().__init__(function_name, object_instance)
         self._step_name = step_name
         self._is_decorator_based = is_decorator_based
+        self._decorator_guard_cache: ModelFunction | None | object = _GUARD_NOT_CACHED
 
     @property
     def name(self) -> str:
@@ -114,7 +118,11 @@ def _find_decorator_guard(self) -> Optional['ModelFunction']:
 
         Uses inspect.getmembers() for robust introspection.
         Supports both instance methods and static methods.
+        Result is cached after first lookup since decorator guards are static.
         """
+        if self._decorator_guard_cache is not _GUARD_NOT_CACHED:
+            return self._decorator_guard_cache  # type: ignore[return-value]
+
         for attr_name, method in inspect.getmembers(self.object_instance, predicate=callable):
             # Skip private/protected methods
             if attr_name.startswith('_'):
@@ -125,7 +133,10 @@ def _find_decorator_guard(self) -> Optional['ModelFunction']:
                 and hasattr(method, '_osmo_guard_for')
                 and method._osmo_guard_for == self.name
             ):
-                return ModelFunction(attr_name, self.object_instance)
+                self._decorator_guard_cache = ModelFunction(attr_name, self.object_instance)
+                return self._decorator_guard_cache
+
+        self._decorator_guard_cache = None
         return None
 
     @property