pythagoras 0.8.14__tar.gz → 0.9.1__tar.gz

{pythagoras-0.8.14/pythagoras.egg-info → pythagoras-0.9.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pythagoras
-Version: 0.8.14
+Version: 0.9.1
 Summary: Simple framework for planet-scale idempotent computations in Python.
 Home-page: https://github.com/vladlpavlov/pythagoras
 Author: Volodymyr (Vlad) Pavlov

{pythagoras-0.8.14 → pythagoras-0.9.1}/pythagoras/_01_foundational_objects/value_addresses.py

@@ -38,8 +38,8 @@ class ValueAddress(HashAddress):
 
         super().__init__(prefix, hash_value)
 
-        if push_to_cloud and not (self in pth.global_value_store):
-            pth.global_value_store[self] = data
+        if push_to_cloud and not (self in pth.value_store):
+            pth.value_store[self] = data
 
     def get_ValueAddress(self):
         return self
@@ -47,12 +47,12 @@ class ValueAddress(HashAddress):
     @property
     def ready(self):
         """Check if address points to a value that is ready to be retrieved."""
-        return self in pth.global_value_store
+        return self in pth.value_store
 
 
     def get(self, timeout:Optional[int] = None) -> Any:
         """Retrieve value, referenced by the address"""
-        return pth.global_value_store[self]
+        return pth.value_store[self]
 
     def get_typed(self
             ,expected_type:Type[T]

{pythagoras-0.8.14 → pythagoras-0.9.1}/pythagoras/_03_autonomous_functions/__init__.py

@@ -44,7 +44,7 @@ from pythagoras._03_autonomous_functions.default_island_singleton import (
     DefaultIsland, DefaultIslandType)
 
 from pythagoras._03_autonomous_functions.autonomous_funcs import (
-    AutonomousFunction, post_event, print_event)
+    AutonomousFunction)
 
 from pythagoras._03_autonomous_functions.autonomicity_checks import (
     is_autonomous, is_loosely_autonomous, is_strictly_autonomous)

{pythagoras-0.8.14 → pythagoras-0.9.1}/pythagoras/_03_autonomous_functions/autonomous_decorators.py

@@ -66,7 +66,7 @@ class autonomous:
         self.island_name = island_name
         self.require_pth = require_pth
 
-    def __call__(self, a_func: Callable) -> Callable:
+    def __call__(self, a_func: Callable) -> AutonomousFunction:
         """Decorator for autonomous functions.
 
         It does both static and dynamic checks for autonomous functions.

{pythagoras-0.8.14 → pythagoras-0.9.1}/pythagoras/_03_autonomous_functions/autonomous_funcs.py

@@ -4,7 +4,7 @@ import sys
 import traceback
 from typing import Callable, Optional, Any
 from persidict import replace_unsafe_chars
-import pythagoras as pth
+
 
 from pythagoras._02_ordinary_functions.ordinary_funcs import (
     OrdinaryFunction)
@@ -18,15 +18,16 @@ from pythagoras._03_autonomous_functions.call_graph_explorer import (
 from pythagoras._03_autonomous_functions.names_usage_analyzer import (
     analyze_names_in_function)
 
-from pythagoras._05_events_and_exceptions.find_in_callstack import (
-    find_local_var_in_callstack)
+from pythagoras._03_autonomous_functions.pth_available_names_retriever import (
+    retrieve_objs_available_inside_autonomous_functions)
 
-from pythagoras._05_events_and_exceptions.event_logger import (
-    log_exception)
+from pythagoras._05_events_and_exceptions.global_event_loggers import (
+    register_exception_globally)
 
 from pythagoras._06_mission_control.global_state_management import (
     is_correctly_initialized)
 
+import pythagoras as pth
 
 
 class AutonomousFunction(OrdinaryFunction):
@@ -123,6 +124,8 @@ class AutonomousFunction(OrdinaryFunction):
         import_required -= set(pth.primary_decorators)
         builtin_names = set(dir(builtins))
         import_required -= builtin_names
+        pth_names = set(retrieve_objs_available_inside_autonomous_functions())
+        import_required -= pth_names
         import_required -= {name}
         if self.island_name is not None:
             island = pth.all_autonomous_functions[self.island_name]
@@ -146,7 +149,7 @@ class AutonomousFunction(OrdinaryFunction):
     def execute(self, **kwargs) -> Any:
         try:
             assert self.runtime_checks()
-            names_dict = dict()
+            names_dict = retrieve_objs_available_inside_autonomous_functions()
             island = pth.all_autonomous_functions[self.island_name]
             names_dict["_pth_kwargs"] = kwargs
             if self.island_name is not None:
@@ -155,6 +158,7 @@ class AutonomousFunction(OrdinaryFunction):
             else:
                 names_dict[self.name] = island[self.name]
 
+
             tmp_name = "_pth_tmp_" + self.name
             source_to_exec = self.naked_source_code + "\n"
             source_to_exec = source_to_exec.replace(
@@ -164,7 +168,11 @@ class AutonomousFunction(OrdinaryFunction):
             result = names_dict["_pth_result"]
             return result
         except Exception as e:
-            log_exception()
+            if self.__class__ == AutonomousFunction:
+                exception_id = f"{self.name}_{self.island_name}"
+                exception_id += f"_{e.__class__.__name__}"
+                exception_id += f"_{pth.get_random_signature()}"
+                register_exception_globally(exception_id=exception_id)
             raise e
 
     def __call__(self, **kwargs) -> Any:
@@ -231,61 +239,4 @@ def register_autonomous_function(f: AutonomousFunction) -> None:
     if f is not pth.all_autonomous_functions[f.island_name][f.name]:
         assert not hasattr(f, "_static_checks_passed")
         assert not hasattr(f, "_runtime_checks_passed")
-        assert not hasattr(f, "_dependencies")
-
-
-class EventPosterFactory:
-    def __init__(self, silent:bool = False):
-        assert isinstance(silent, bool)
-        self.silent = silent
-
-    def __getitem__(self, item:str)-> EventPoster:
-        assert isinstance(item, str)
-        return EventPoster(item, silent=self.silent)
-
-class EventPoster:
-    def __init__(self, label:str, silent:bool = False):
-        assert isinstance(label, str)
-        assert label == replace_unsafe_chars(label, "")
-        assert 0 < len(label) < 25
-        self.label = label
-        self.silent = silent
-
-    def __call__(self, **event_args)-> None:
-        callers = find_local_var_in_callstack(name_to_find="self"
-                                              , class_to_find=AutonomousFunction)
-        caller_name = ""
-        if len(callers) > 0:
-            caller_name = callers[0].name
-            caller_prefix = caller_name + "_"
-            caller_type = callers[0].__class__.__name__
-        else:
-            caller_name = "__none__"
-            caller_prefix = caller_name
-            caller_type = "AutonomousFunction"
-        prefix = caller_prefix + self.label
-        logger = EventLogger(event_log=pth.global_event_log
-            , prefix=prefix, save_context=False)
-
-        if not self.silent:
-            print(30*"~")
-            print(f"Event '{self.label}' "
-                  + f"inside an {caller_type} '{caller_name}':")
-            for key, value in event_args.items():
-                print(f"    {key} = {value}")
-            print()
-
-        label_arg_name = "event_label"
-        while label_arg_name in event_args:
-            label_arg_name += "_"
-        event_args[label_arg_name] = self.label
-
-        caller_arg_name = "caller_name"
-        while caller_arg_name in event_args:
-            caller_arg_name += "_"
-        event_args[caller_arg_name] = caller_name
-
-        logger.log_event(**event_args)
-
-post_event: EventPosterFactory = EventPosterFactory(silent=True)
-print_event: EventPosterFactory = EventPosterFactory(silent=False)
+        assert not hasattr(f, "_dependencies")

pythagoras-0.9.1/pythagoras/_03_autonomous_functions/pth_available_names_retriever.py

@@ -0,0 +1,13 @@
+import sys
+from typing import Any
+
+
+def retrieve_objs_available_inside_autonomous_functions() -> dict[str,Any]:
+    """Names available inside autonomous functions without explicit import.
+
+   """
+    result = dict(
+        pth = sys.modules['pythagoras']
+        , post_event = sys.modules['pythagoras'].post_event
+        )
+    return result

{pythagoras-0.8.14 → pythagoras-0.9.1}/pythagoras/_04_idempotent_functions/__init__.py

@@ -2,7 +2,9 @@ from pythagoras._04_idempotent_functions.kw_args import (
     SortedKwArgs, PackedKwArgs, UnpackedKwArgs)
 
 from pythagoras._04_idempotent_functions.idempotent_func_and_address import (
-    IdempotentFunction, FuncOutputAddress)
+    IdempotentFunction
+    , FunctionExecutionResultAddress
+    , FunctionExecutionContext)
 
 from pythagoras._04_idempotent_functions.idempotent_decorator import (
     idempotent)

{pythagoras-0.8.14 → pythagoras-0.9.1}/pythagoras/_04_idempotent_functions/idempotent_decorator.py

@@ -28,7 +28,7 @@ class idempotent:
         self.require_pth = require_pth
 
 
-    def __call__(self, a_func:Callable) -> Callable:
+    def __call__(self, a_func:Callable) -> IdempotentFunction:
         if not self.require_pth and is_fully_unitialized():
             wrapper = a_func
             logging.warning(f"Decorator @{self.__class__.__name__}()"

{pythagoras-0.8.14 → pythagoras-0.9.1}/pythagoras/_04_idempotent_functions/idempotent_func_and_address.py

@@ -1,10 +1,13 @@
 from __future__ import annotations
 
 import time
+import traceback
 from typing import Callable, Any
 
+from persidict import PersiDict
+
 import pythagoras as pth
-from pythagoras import get_random_signature
+from pythagoras import get_random_signature, OutputCapturer
 
 from pythagoras._01_foundational_objects.hash_addresses import HashAddress
 from pythagoras._01_foundational_objects.value_addresses import ValueAddress
@@ -22,7 +25,9 @@ from pythagoras._04_idempotent_functions.kw_args import (
     UnpackedKwArgs, PackedKwArgs, SortedKwArgs)
 from pythagoras._04_idempotent_functions.process_augmented_func_src import (
     process_augmented_func_src)
-from pythagoras._05_events_and_exceptions.context_utils import build_context
+from pythagoras._05_events_and_exceptions.context_utils import build_context, add_context
+from pythagoras._05_events_and_exceptions.global_event_loggers import (
+    register_exception_globally, register_event_globally)
 
 
 class IdempotentFunction(AutonomousFunction):
@@ -108,21 +113,26 @@ class IdempotentFunction(AutonomousFunction):
 
         self.augmented_code_checked = True
 
+    def get_address(self, **kwargs) -> FunctionExecutionResultAddress:
+        packed_kwargs = PackedKwArgs(**kwargs)
+        output_address = FunctionExecutionResultAddress(self, packed_kwargs)
+        return output_address
+
 
     def execute(self, **kwargs) -> Any:
         packed_kwargs = PackedKwArgs(**kwargs)
-        output_address = FuncOutputAddress(self, packed_kwargs)
+        output_address = FunctionExecutionResultAddress(self, packed_kwargs)
         _pth_f_addr_ = output_address
         if output_address.ready:
             return output_address.get()
-        output_address.request_execution()
-        registration_addr = (output_address[1], get_random_signature())
-        pth.function_execution_attempts[registration_addr] = build_context()
-        unpacked_kwargs = UnpackedKwArgs(**packed_kwargs)
-        result = super().execute(**unpacked_kwargs)
-        pth.function_output_store[output_address] = ValueAddress(result)
-        pth.function_execution_requests.delete_if_exists(output_address)
-        return result
+        with FunctionExecutionContext(output_address) as _pth_ec:
+            output_address.request_execution()
+            _pth_ec.register_execution_attempt()
+            unpacked_kwargs = UnpackedKwArgs(**packed_kwargs)
+            result = super().execute(**unpacked_kwargs)
+            pth.execution_results[output_address] = ValueAddress(result)
+            output_address.drop_execution_request()
+            return result
 
     def list_execute(self, list_of_kwargs:list[dict]) -> Any:
         assert isinstance(list_of_kwargs, (list, tuple))
@@ -130,7 +140,7 @@ class IdempotentFunction(AutonomousFunction):
             assert isinstance(kwargs, dict)
         addrs = []
         for kwargs in list_of_kwargs:
-            new_addr = FuncOutputAddress(self, kwargs)
+            new_addr = FunctionExecutionResultAddress(self, kwargs)
             new_addr.request_execution()
             addrs.append(new_addr)
         addrs_indexed = list(zip(range(len(addrs)), addrs))
@@ -141,11 +151,6 @@ class IdempotentFunction(AutonomousFunction):
         results_list = [results_dict[n] for n in range(len(addrs))]
         return results_list
 
-    def execution_attempts(self, **kwargs) -> list:
-        packed_kwargs = PackedKwArgs(**kwargs)
-        output_address = FuncOutputAddress(self, packed_kwargs)
-        return output_address.execution_attempts
-
 
 def register_idempotent_function(f: IdempotentFunction) -> None:
     """Register an idempotent function in the Pythagoras system."""
@@ -166,7 +171,7 @@ class FunctionCallSignature:
         self.f_addr = ValueAddress(f)
         self.args_addr = ValueAddress(arguments.pack())
 
-class FuncOutputAddress(HashAddress):
+class FunctionExecutionResultAddress(HashAddress):
     value_prefix: str|None = None
     def __init__(self, f: IdempotentFunction, arguments:dict[str, Any]):
         assert isinstance(f, IdempotentFunction)
@@ -186,16 +191,25 @@ class FuncOutputAddress(HashAddress):
 
     @property
     def ready(self):
-        result =  self in pth.function_output_store
+        result =  self in pth.execution_results
         return result
 
     def request_execution(self):
-        if self in pth.function_output_store:
-            if self in pth.function_execution_requests:
-                del pth.function_execution_requests[self]
+        request_address = self + ["execution_requested"]
+        if self in pth.execution_results:
+            if request_address in pth.operational_hub.binary:
+                del pth.operational_hub.binary[request_address]
         else:
-            if self not in pth.function_execution_requests:
-                pth.function_execution_requests[self] = True
+            if request_address not in pth.operational_hub.binary:
+                pth.operational_hub.binary[request_address] = True
+
+    def drop_execution_request(self):
+        request_address = self + ["execution_requested"]
+        pth.operational_hub.binary.delete_if_exists(request_address)
+
+    def is_execution_requested(self):
+        request_address = self + ["execution_requested"]
+        return request_address in pth.operational_hub.binary
 
     def get(self, timeout: int = None):
         """Retrieve value, referenced by the address.
@@ -204,7 +218,7 @@ class FuncOutputAddress(HashAddress):
         till timeout is exceeded. If timeout is None, keep trying forever.
         """
         if self.ready:
-            return pth.global_value_store[pth.function_output_store[self]]
+            return pth.value_store[pth.execution_results[self]]
         self.request_execution()
 
         start_time, backoff_period = time.time(), 1.0
@@ -213,8 +227,8 @@ class FuncOutputAddress(HashAddress):
 
         while True:
             if self.ready:
-                result = pth.global_value_store[pth.function_output_store[self]]
-                pth.function_execution_requests.delete_if_exists(self)
+                result = pth.value_store[pth.execution_results[self]]
+                self.drop_execution_request()
                 return result
             else:
                 time.sleep(backoff_period)
@@ -273,7 +287,7 @@ class FuncOutputAddress(HashAddress):
         # TODO: these should not be constants
         if self.ready:
             return False
-        past_attempts = pth.function_execution_attempts.get_subdict(self)
+        past_attempts = self.execution_attempts
         n_past_attempts = len(past_attempts)
         if n_past_attempts == 0:
             return True
@@ -289,12 +303,89 @@ class FuncOutputAddress(HashAddress):
         return False
 
     @property
-    def execution_attempts(self) -> list:
-        attempts = pth.function_execution_attempts.get_subdict(self[1])
-        attemps_timed = {-attempts.mtimestamp(a):attempts[a] for a in attempts}
-        times = sorted(attemps_timed)
-        result = []
-        for t in times:
-            result.append(attemps_timed[t])
-        return result
+    def execution_attempts(self) -> PersiDict:
+        attempts_path = self + ["attempts"]
+        attempts = pth.operational_hub.jason.get_subdict(attempts_path)
+        return attempts
+
+    @property
+    def execution_outputs(self) -> PersiDict:
+        outputs_path = self + ["outputs"]
+        outputs = pth.operational_hub.text.get_subdict(outputs_path)
+        return outputs
 
+    @property
+    def crashes(self) -> PersiDict:
+        crashes_path = self + ["crashes"]
+        crashes = pth.operational_hub.jason.get_subdict(crashes_path)
+        return crashes
+
+    @property
+    def events(self) -> PersiDict:
+        events_path = self + ["events"]
+        events = pth.operational_hub.jason.get_subdict(events_path)
+        return events
+
+class FunctionExecutionContext:
+    session_id: str
+    f_address: FunctionExecutionResultAddress
+    output_capturer = OutputCapturer
+    exception_counter: int
+    event_counter: int
+
+    def __init__(self, f_address: FunctionExecutionResultAddress):
+        self.session_id = get_random_signature()
+        self.f_address = f_address
+        self.output_capturer = OutputCapturer()
+        self.exception_counter = 0
+        self.event_counter = 0
+
+    def __enter__(self):
+        self.output_capturer.__enter__()
+        return self
+
+    def __exit__(self, exc_type, exc_value, trace_back):
+        self.output_capturer.__exit__(exc_type, exc_value, traceback)
+
+        output_id = self.session_id+"_o"
+        execution_outputs = self.f_address.execution_outputs
+        execution_outputs[output_id] = self.output_capturer.get_output()
+
+        self.register_exception(
+            exc_type=exc_type, exc_value=exc_value, trace_back=trace_back)
+
+
+    def register_execution_attempt(self):
+        execution_attempts = self.f_address.execution_attempts
+        attempt_id = self.session_id+"_a"
+        execution_attempts[attempt_id] = build_context()
+
+
+    def register_exception(self,exc_type, exc_value, trace_back, **kwargs):
+        if exc_value is None:
+            return
+        exception_id = self.session_id + f"_c_{self.exception_counter}"
+        self.f_address.crashes[exception_id] = add_context(
+            **kwargs, exc_value=exc_value)
+        self.exception_counter += 1
+        exception_id = exc_type.__name__ + "_"+ exception_id
+        exception_id = self.f_address.island_name + "_" + exception_id
+        exception_id = self.f_address.f_name + "_" + exception_id
+        register_exception_globally(**kwargs, exception_id=exception_id)
+
+    def register_event(self, event_type:str|None=None, **kwargs):
+        event_id = self.session_id + f"_e_{self.event_counter}"
+        if event_type is not None:
+            event_id += "_"+ event_type
+        events = self.f_address.events
+        events[event_id] = add_context(**kwargs, event_type=event_type)
+
+        event_id = self.session_id + f"_e_{self.event_counter}"
+        if event_type is not None:
+            kwargs["event_type"] = event_type
+            event_id = event_type + "_"+ event_id
+        event_id = self.f_address.island_name + "_" + event_id
+        event_id = self.f_address.f_name + "_" + event_id
+        register_event_globally(**kwargs, event_id=event_id)
+
+        self.event_counter += 1

{pythagoras-0.8.14 → pythagoras-0.9.1}/pythagoras/_04_idempotent_functions/kw_args.py

@@ -25,7 +25,7 @@ class SortedKwArgs(dict):
         unpacked_copy = dict()
         for k,v in self.items():
             if isinstance(v, ValueAddress):
-                unpacked_copy[k] = pth.global_value_store[v]
+                unpacked_copy[k] = pth.value_store[v]
             else:
                 unpacked_copy[k] = v
         return unpacked_copy

pythagoras-0.9.1/pythagoras/_05_events_and_exceptions/__init__.py

@@ -0,0 +1,5 @@
+from pythagoras._05_events_and_exceptions.notebook_checker import (
+    is_executed_in_notebook)
+
+from pythagoras._05_events_and_exceptions.event_poster import (
+    post_event)

pythagoras-0.9.1/pythagoras/_05_events_and_exceptions/event_poster.py

@@ -0,0 +1,53 @@
+
+from pythagoras._01_foundational_objects.hash_and_random_signatures import (
+    get_random_signature)
+from pythagoras._05_events_and_exceptions.type_retrievers import (
+    retrieve_FunctionExecutionContext_class)
+from pythagoras._05_events_and_exceptions.find_in_callstack import \
+    find_local_var_in_callstack
+from pythagoras._05_events_and_exceptions.global_event_loggers import (
+    register_event_globally)
+
+import pythagoras as pth
+
+
+def get_current_function_execution_context():
+    all_context_objects = find_local_var_in_callstack(name_to_find="_pth_ec"
+        , class_to_find=retrieve_FunctionExecutionContext_class())
+    if len(all_context_objects) > 0:
+        return all_context_objects[0]
+    else:
+        return None
+
+
+class EventPosterFactory:
+    def __init__(self):
+        pass
+
+    def __getitem__(self, item):
+        return EventPoster(event_type = item)
+
+    def __call__(self, **kwargs):
+        return EventPoster(event_type = None)(**kwargs)
+
+class EventPoster:
+    def __init__(self, event_type: str|None):
+        assert isinstance(event_type, (str, type(None)))
+        self.event_type = event_type
+
+    def __call__(self,**kwargs) -> None:
+        assert pth.is_correctly_initialized(), (
+            "The Pythagoras package has not been correctly initialized.")
+        context = get_current_function_execution_context()
+        if context is not None:
+            context.register_event(event_type = self.event_type, **kwargs)
+        else:
+            if self.event_type is not None:
+                kwargs["event_type"] = self.event_type
+                event_id = self.event_type + "_" + get_random_signature()
+            else:
+                event_id = get_random_signature()
+            register_event_globally(**kwargs, event_id = event_id)
+
+post_event = EventPosterFactory()
+

pythagoras-0.9.1/pythagoras/_05_events_and_exceptions/global_event_loggers.py

@@ -0,0 +1,27 @@
+import sys
+
+from pythagoras._05_events_and_exceptions.context_utils import add_context
+from pythagoras._05_events_and_exceptions.current_date_gmt_str import (
+    current_date_gmt_string)
+from pythagoras import get_random_signature
+
+import pythagoras as pth
+
+
+
+def register_exception_globally(exception_id = None, **kwargs):
+    path = current_date_gmt_string()
+    exc_type, exc_value, trace_back = sys.exc_info()
+    if exception_id is None:
+        exception_id = exc_type.__name__ + "_" + get_random_signature()
+    full_path = [path, exception_id]
+    pth.crash_history[full_path] = add_context(
+        exc_value=exc_value, **kwargs)
+
+
+def register_event_globally(event_id = None, **kwargs):
+    path = current_date_gmt_string()
+    if event_id is None:
+        event_id = get_random_signature()
+    full_path = [path, event_id]
+    pth.event_log[full_path] = add_context(**kwargs)

{pythagoras-0.8.14 → pythagoras-0.9.1}/pythagoras/_05_events_and_exceptions/type_retrievers.py

@@ -18,13 +18,22 @@ def retrieve_AutonomousFunction_class() -> type:
     return sys.modules['pythagoras'].AutonomousFunction
 
 
-def retrieve_FuncOutputAddress_class() -> type:
-    """Return the FuncOutputAddress class.
+def retrieve_FunctionExecutionResultAddress_class() -> type:
+    """Return the FunctionExecutionResultAddress class.
 
     This is for-internal-use-only function, created to
     avoid circular import dependencies.
     """
-    return sys.modules['pythagoras'].FuncOutputAddress
+    return sys.modules['pythagoras'].FunctionExecutionResultAddress
+
+
+def retrieve_FunctionExecutionContext_class() -> type:
+    """Return the FunctionExecutionContext class.
+
+    This is for-internal-use-only function, created to
+    avoid circular import dependencies.
+    """
+    return sys.modules['pythagoras'].FunctionExecutionContext
 
 
 

{pythagoras-0.8.14 → pythagoras-0.9.1}/pythagoras/_05_events_and_exceptions/uncaught_exception_handlers.py

@@ -1,14 +1,14 @@
 import sys, traceback
 
 from pythagoras._05_events_and_exceptions.notebook_checker import is_executed_in_notebook
-from pythagoras._05_events_and_exceptions.event_logger import log_exception
-
+from pythagoras._05_events_and_exceptions.global_event_loggers import (
+    register_exception_globally)
 
 import pythagoras as pth
 
 
 # def log_uncaught_exception(exception: Exception, **kwargs):
-#     logger = EventLogger(event_log = pth.global_crash_history
+#     logger = EventLogger(event_log = pth.crash_history
 #         , prefix = "__none__"+ exception.__class__.__name__
 #         , save_context = True)
 #     logger.log_event(exception=exception, **kwargs)
@@ -21,7 +21,7 @@ def pth_excepthook(exc_type, exc_value, trace_back) -> None:
     #     exc_type, exc_value, trace_back)
     # log_uncaught_exception(exception = exc_value
     #     , exception_description = exception_description)
-    log_exception()
+    register_exception_globally()
     sys.__excepthook__(exc_type, exc_value, trace_back)
 
 def pth_excepthandler(_, exc_type, exc_value
@@ -30,7 +30,7 @@ def pth_excepthandler(_, exc_type, exc_value
     #     exc_type, exc_value, trace_back)
     # log_uncaught_exception(exception=exc_value
     #     , exception_description=exception_description)
-    log_exception()
+    register_exception_globally()
     traceback.print_exception(exc_type, exc_value, trace_back)
 
 

{pythagoras-0.8.14 → pythagoras-0.9.1}/pythagoras/_06_mission_control/__init__.py

@@ -10,3 +10,6 @@ from pythagoras._06_mission_control.global_state_management import (
     )
 
 from pythagoras._06_mission_control.summary import summary
+
+from pythagoras._06_mission_control.operational_hub import (
+    OperationalHub)