improved performance of collection, and skipping tests that don't need to run locally

Author: DinisCruz

osbot_utils/helpers/timestamp_capture/schemas/Schema__Method_Timing.py

@@ -1,10 +1,16 @@
-from osbot_utils.type_safe.Type_Safe import Type_Safe
+from dataclasses import dataclass
 
-
-class Schema__Method_Timing(Type_Safe):                     # Aggregated timing for a method
+@dataclass(slots=True)
+class Schema__Method_Timing():                               # Aggregated timing for a method
     name        : str   = ''
     call_count  : int   = 0
     total_ns    : int   = 0
     min_ns      : int   = 0
     max_ns      : int   = 0
-    self_ns     : int   = 0                                 # Exclusive time (minus children)
+    self_ns     : int   = 0                                 # Exclusive time (minus children)
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        return False

osbot_utils/helpers/timestamp_capture/schemas/Schema__Timestamp_Entry.py

@@ -1,12 +1,18 @@
+from dataclasses import dataclass
 from typing                          import Dict, Any
-from osbot_utils.type_safe.Type_Safe import Type_Safe
 
-
-class Schema__Timestamp_Entry(Type_Safe):                   # Single timestamp capture entry
+@dataclass(slots=True)
+class Schema__Timestamp_Entry:
     name         : str              = ''
     event        : str              = ''                    # 'enter' | 'exit'
     timestamp_ns : int              = 0                     # perf_counter_ns (monotonic)
     clock_ns     : int              = 0                     # time_ns (wall clock)
     thread_id    : int              = 0
     depth        : int              = 0
-    extra        : Dict[str, Any]   = None
+    extra        : Dict[str, Any]   = None
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        return False

tests/unit/helpers/timestamp_capture/decorators/test_timestamp.py

@@ -1,5 +1,8 @@
 import time
 from unittest                                                                      import TestCase
+
+from osbot_fast_api_serverless.utils.testing.skip_tests import skip__if_not__in_github_actions
+
 from osbot_utils.helpers.timestamp_capture.Timestamp_Collector                     import Timestamp_Collector
 from osbot_utils.helpers.timestamp_capture.decorators.timestamp                    import timestamp
 from osbot_utils.type_safe.Type_Safe                                               import Type_Safe
@@ -146,6 +149,7 @@ def repeated():
         assert _timestamp_collector_.method_count() == 1                           # Still just one unique method
 
     def test_timestamp__timing_accuracy(self):                                     # Test timing is reasonably accurate
+        skip__if_not__in_github_actions()
         @timestamp
         def sleep_function():
             time.sleep(0.01)                                                       # 10ms

tests/unit/helpers/timestamp_capture/decorators/test_timestamp_block.py

@@ -1,5 +1,8 @@
 import time
 from unittest                                                                         import TestCase
+
+from osbot_fast_api_serverless.utils.testing.skip_tests import skip__if_not__in_github_actions
+
 from osbot_utils.helpers.timestamp_capture.Timestamp_Collector                        import Timestamp_Collector
 from osbot_utils.helpers.timestamp_capture.context_managers.timestamp_block           import timestamp_block
 
@@ -66,6 +69,7 @@ def test_timestamp_block__with_exception(self):
         assert _timestamp_collector_.entries[1].event  == 'exit'
 
     def test_timestamp_block__timing_accuracy(self):                                  # Test timing is reasonably accurate
+        skip__if_not__in_github_actions()
         _timestamp_collector_ = Timestamp_Collector()
 
         with _timestamp_collector_:

tests/unit/helpers/timestamp_capture/schemas/test_Schema__Method_Timing.py

@@ -9,7 +9,7 @@ class test_Schema__Method_Timing(TestCase):
     def test__init__(self):                                                      # Test auto-initialization of schema
         with Schema__Method_Timing() as _:
             assert type(_)          is Schema__Method_Timing
-            assert base_classes(_)  == [Type_Safe, object]
+            assert base_classes(_)  == [object]
             assert _.name           == ''
             assert _.call_count     == 0
             assert _.total_ns       == 0
@@ -29,21 +29,4 @@ def test__init____with_values(self):                                         # T
             assert _.total_ns       == 50_000_000
             assert _.min_ns         == 3_000_000
             assert _.max_ns         == 8_000_000
-            assert _.self_ns        == 30_000_000
-
-    def test__json_round_trip(self):                                             # Test serialization round-trip
-        with Schema__Method_Timing(name       = 'convert'          ,
-                                   call_count = 5                  ,
-                                   total_ns   = 100_000_000        ,
-                                   min_ns     = 15_000_000         ,
-                                   max_ns     = 25_000_000         ,
-                                   self_ns    = 60_000_000         ) as _:
-            json_data = _.json()
-            recreated = Schema__Method_Timing.from_json(json_data)
-
-            assert recreated.name       == _.name
-            assert recreated.call_count == _.call_count
-            assert recreated.total_ns   == _.total_ns
-            assert recreated.min_ns     == _.min_ns
-            assert recreated.max_ns     == _.max_ns
-            assert recreated.self_ns    == _.self_ns
+            assert _.self_ns        == 30_000_000

tests/unit/helpers/timestamp_capture/schemas/test_Schema__Timestamp_Entry.py

@@ -9,7 +9,7 @@ class test_Schema__Timestamp_Entry(TestCase):
     def test__init__(self):                                                        # Test auto-initialization of schema
         with Schema__Timestamp_Entry() as _:
             assert type(_)              is Schema__Timestamp_Entry
-            assert base_classes(_)      == [Type_Safe, object]
+            assert base_classes(_)      == [object]
             assert _.name               == ''
             assert _.event              == ''
             assert _.timestamp_ns       == 0
@@ -32,21 +32,4 @@ def test__init____with_values(self):                                           #
             assert _.clock_ns           == 987654321
             assert _.thread_id          == 12345
             assert _.depth              == 3
-            assert _.extra              == {'key': 'val'}
-
-    def test__json_round_trip(self):                                               # Test serialization round-trip
-        with Schema__Timestamp_Entry(name         = 'method_a'     ,
-                                     event        = 'exit'         ,
-                                     timestamp_ns = 111111111      ,
-                                     clock_ns     = 222222222      ,
-                                     thread_id    = 999            ,
-                                     depth        = 2              ) as _:
-            json_data  = _.json()
-            recreated  = Schema__Timestamp_Entry.from_json(json_data)
-
-            assert recreated.name         == _.name
-            assert recreated.event        == _.event
-            assert recreated.timestamp_ns == _.timestamp_ns
-            assert recreated.clock_ns     == _.clock_ns
-            assert recreated.thread_id    == _.thread_id
-            assert recreated.depth        == _.depth
+            assert _.extra              == {'key': 'val'}