pythagoras 0.24.8__py3-none-any.whl → 0.24.10__py3-none-any.whl

pythagoras/_010_basic_portals/__init__.py

@@ -32,7 +32,6 @@ be subclassed to provide additional functionality.
 """
 
 from .post_init_metaclass import *
-from .exceptions import *
 from .basic_portal_core_classes import *
 from .portal_tester import _PortalTester
 from .long_infoname import *

pythagoras/_010_basic_portals/basic_portal_core_classes.py

@@ -65,8 +65,8 @@ def _describe_runtime_characteristic(name, value) -> pd.DataFrame:
     return pd.DataFrame(d)
 
 
-BASE_DIRECTORY_TXT = "Base directory"
-BACKEND_TYPE_TXT = "Backend type"
+_BASE_DIRECTORY_TXT = "Base directory"
+_BACKEND_TYPE_TXT = "Backend type"
 
 
 def _get_description_value_by_key(dataframe:pd.DataFrame, key:str) -> Any:
@@ -200,7 +200,8 @@ def get_default_portal_base_dir() -> str:
     target_directory = home_directory / ".pythagoras" / ".default_portal"
     target_directory.mkdir(parents=True, exist_ok=True)
     target_directory_str = str(target_directory.resolve())
-    assert isinstance(target_directory_str, str)
+    if not isinstance(target_directory_str, str):
+        raise TypeError(f"Expected target_directory_str to be str, got {type(target_directory_str).__name__}")
     return target_directory_str
 
 
@@ -280,8 +281,10 @@ class BasicPortal(NotPicklableClass,ParameterizableClass, metaclass = PostInitMe
         global _all_links_from_objects_to_portals
         result = set()
         for obj_str_id, portal_str_id in _all_links_from_objects_to_portals.items():
-            assert isinstance(obj_str_id, str)
-            assert isinstance(portal_str_id, str)
+            if not isinstance(obj_str_id, str):
+                raise TypeError(f"Expected obj_str_id to be str, got {type(obj_str_id).__name__}")
+            if not isinstance(portal_str_id, str):
+                raise TypeError(f"Expected portal_str_id to be str, got {type(portal_str_id).__name__}")
             if portal_str_id == self._str_id:
                 if target_class is None:
                     result.add(obj_str_id)
@@ -386,9 +389,9 @@ class BasicPortal(NotPicklableClass,ParameterizableClass, metaclass = PostInitMe
         all_params = []
 
         all_params.append(_describe_persistent_characteristic(
-            BASE_DIRECTORY_TXT, self._root_dict.base_dir))
+            _BASE_DIRECTORY_TXT, self._root_dict.base_dir))
         all_params.append(_describe_persistent_characteristic(
-            BACKEND_TYPE_TXT, self._root_dict.__class__.__name__))
+            _BACKEND_TYPE_TXT, self._root_dict.__class__.__name__))
 
         result = pd.concat(all_params)
         result.reset_index(drop=True, inplace=True)
@@ -411,10 +414,9 @@ class BasicPortal(NotPicklableClass,ParameterizableClass, metaclass = PostInitMe
     def __exit__(self, exc_type, exc_val, exc_tb):
         """Pop the portal from the stack of active ones"""
         global _active_portals_stack, _active_portals_counters_stack
-        assert _active_portals_stack[-1] == self, (
-            "Inconsistent state of the portal stack. "
-            + "Most probably, portal.__enter__() method was called explicitly "
-            + "within a 'with' statement with another portal.")
+        if _active_portals_stack[-1] != self:
+            raise RuntimeError(
+                "Inconsistent state of the portal stack. Most probably, portal.__enter__() method was called explicitly within a 'with' statement with another portal.")
         if _active_portals_counters_stack[-1] == 1:
             _active_portals_stack.pop()
             _active_portals_counters_stack.pop()
@@ -462,7 +464,8 @@ class PortalAwareClass(metaclass = PostInitMeta):
             portal: The portal to link this object to, or None to use the
                 currently active portal for operations.
         """
-        assert portal is None or isinstance(portal, BasicPortal)
+        if not (portal is None or isinstance(portal, BasicPortal)):
+            raise TypeError(f"portal must be a BasicPortal or None, got {type(portal).__name__}")
         self._linked_portal_at_init = portal
         # self._hash_id_cache = None
         self._visited_portals = set()
@@ -501,7 +504,8 @@ class PortalAwareClass(metaclass = PostInitMeta):
             portal = self._linked_portal_at_init
         elif self._str_id in _all_links_from_objects_to_portals:
             portal_str_id = _all_links_from_objects_to_portals[self._str_id]
-            assert isinstance(portal_str_id, str)
+            if not isinstance(portal_str_id, str):
+                raise TypeError(f"Expected portal_str_id to be str, got {type(portal_str_id).__name__}")
             portal = _all_known_portals[portal_str_id]
         return portal
 
@@ -595,7 +599,8 @@ class PortalAwareClass(metaclass = PostInitMeta):
         """Return True if the object has been registered in at least one of the portals."""
         global _all_activated_portal_aware_objects
         if len(self._visited_portals) >=1:
-            assert self._str_id in _all_activated_portal_aware_objects
+            if self._str_id not in _all_activated_portal_aware_objects:
+                raise RuntimeError(f"Object with id {self._str_id} is expected to be in the activated objects registry")
             return True
         return False
 
@@ -606,7 +611,8 @@ class PortalAwareClass(metaclass = PostInitMeta):
         Empty the list of portals it has been registered into.
         """
         global _all_activated_portal_aware_objects
-        assert self.is_activated
+        if not self.is_activated:
+            raise RuntimeError(f"Object with id {self._str_id} is not activated")
         del _all_activated_portal_aware_objects[self._str_id]
         self._invalidate_cache()
         self._visited_portals = set()

pythagoras/_010_basic_portals/portal_tester.py

@@ -25,14 +25,15 @@ class _PortalTester:
 
         Raises:
             Exception: If another _PortalTester instance is already active.
-            AssertionError: If portal_class is not a subclass of BasicPortal.
+            TypeError: If portal_class is not a subclass of BasicPortal.
         """
         if _PortalTester._current_instance is not None:
             raise Exception("_PortalTester can't be nested")
         _PortalTester._current_instance = self
 
         if portal_class is not None:
-            assert issubclass(portal_class, BasicPortal)
+            if not issubclass(portal_class, BasicPortal):
+                raise TypeError(f"portal_class must be a subclass of BasicPortal, got {portal_class}")
         self.portal_class = portal_class
         self.args = args
         self.kwargs = kwargs

pythagoras/_020_ordinary_code_portals/__init__.py

@@ -28,4 +28,5 @@ from .ordinary_portal_core_classes import *
 from .function_processing import *
 from .ordinary_decorator import *
 from .code_normalizer import *
+from .exceptions import *
 

pythagoras/_020_ordinary_code_portals/code_normalizer.py

@@ -1,6 +1,3 @@
-import sys
-
-from .._010_basic_portals.exceptions import NonCompliantFunction
 import ast
 import inspect
 from typing import Callable
@@ -9,6 +6,7 @@ import autopep8
 from .function_processing import get_function_name_from_source
 from .._010_basic_portals.long_infoname import get_long_infoname
 from .function_processing import assert_ordinarity
+from .exceptions import FunctionError
 
 _pythagoras_decorator_names = {
     "ordinary"
@@ -52,12 +50,11 @@ def _get_normalized_function_source_impl(
             A normalized source code string for the function.
 
         Raises:
-            NonCompliantFunction: If the function has multiple decorators when
+            FunctionError: If the function has multiple decorators when
                 a callable or a string representing a single function is
                 expected; or if it fails ordinarity checks.
-            AssertionError: If input is neither a callable nor a string, if
-                parsing assumptions fail (e.g., unexpected AST node types), or
-                when internal integrity checks do not hold.
+            TypeError | ValueError: If input types or parsing assumptions fail
+                (e.g., unexpected AST node types), or when integrity checks do not hold.
             SyntaxError: If the provided source string cannot be parsed.
         """
 
@@ -71,7 +68,7 @@ def _get_normalized_function_source_impl(
             code = a_func
             a_func_name = get_function_name_from_source(code)
         else:
-            assert callable(a_func) or isinstance(a_func, str)
+            raise TypeError(f"a_func must be a callable or a string, got {type(a_func).__name__}")
 
         code_lines = code.splitlines()
 
@@ -88,7 +85,8 @@ def _get_normalized_function_source_impl(
         chars_to_remove = code_no_empty_lines[0][:n_chars_to_remove]
         code_clean_version = []
         for line in code_no_empty_lines:
-            assert line.startswith(chars_to_remove)
+            if not line.startswith(chars_to_remove):
+                raise ValueError(f"Inconsistent indentation detected while normalizing function {a_func_name}")
             cleaned_line = line[n_chars_to_remove:]
             code_clean_version.append(cleaned_line)
 
@@ -97,14 +95,15 @@ def _get_normalized_function_source_impl(
             a_func_name = get_function_name_from_source(code_clean_version)
         code_ast = ast.parse(code_clean_version)
 
-        assert isinstance(code_ast, ast.Module)
-        assert isinstance(code_ast.body[0], ast.FunctionDef), (
-            f"{type(code_ast.body[0])=}")
+        if not isinstance(code_ast, ast.Module):
+            raise TypeError(f"Expected AST Module for {a_func_name}, got {type(code_ast).__name__}")
+        if not isinstance(code_ast.body[0], ast.FunctionDef):
+            raise ValueError(f"Top-level node is not a FunctionDef for {a_func_name}; got {type(code_ast.body[0]).__name__}")
 
         # TODO: add support for multiple decorators???
         decorator_list = code_ast.body[0].decorator_list
         if len(decorator_list) > 1:
-            raise NonCompliantFunction(
+            raise FunctionError(
                 f"Function {a_func_name} can't have multiple decorators,"
                 + " only one decorator is allowed.")
 
@@ -127,7 +126,8 @@ def _get_normalized_function_source_impl(
                         break
                 except:
                     pass
-            assert pth_dec_counter == 1
+            if pth_dec_counter != 1:
+                raise ValueError(f"Unexpected decorator configuration for {a_func_name}: unable to drop Pythagoras decorator")
             code_ast.body[0].decorator_list = []
 
         # Remove docstrings.

pythagoras/_020_ordinary_code_portals/exceptions.py

@@ -0,0 +1,11 @@
+
+
+
+class FunctionError(Exception):
+    """Exception raised when a function does not comply with Pythagoras requirements.
+
+    This exception is raised when a function (or its usage) fails to meet
+    the compliance requirements of the Pythagoras framework.
+    """
+
+    pass

pythagoras/_020_ordinary_code_portals/function_processing.py

@@ -1,7 +1,7 @@
 import types, inspect
 from typing import Callable
 
-from .._010_basic_portals.exceptions import NonCompliantFunction
+from .exceptions import FunctionError
 from .._010_basic_portals.long_infoname import get_long_infoname
 
 
@@ -93,7 +93,7 @@ def assert_ordinarity(a_func: Callable) -> None:
         a_func: The callable to validate.
 
     Raises:
-        NonCompliantFunction: If the callable violates any of the ordinarity
+        FunctionError: If the callable violates any of the ordinarity
             constraints described above (e.g., not a function, is a method,
             is a lambda/closure/async function, accepts *args, or has defaults).
     """
@@ -104,35 +104,35 @@ def assert_ordinarity(a_func: Callable) -> None:
     name = get_long_infoname(a_func)
 
     if not callable(a_func):
-        raise NonCompliantFunction(f"{name} must be callable.")
+        raise FunctionError(f"{name} must be callable.")
 
     if not inspect.isfunction(a_func):
-        raise NonCompliantFunction(f"The function {name} is not ordinary."
+        raise FunctionError(f"The function {name} is not ordinary."
             "It must be a function, not a method, "
             "a classmethod, or a lambda function.")
 
     if isinstance(a_func, types.MethodType):
-        raise NonCompliantFunction(f"The function {name} can't be "
+        raise FunctionError(f"The function {name} can't be "
             "an instance or a class method, only "
             "regular functions are allowed.")
 
     if hasattr(a_func, "__closure__") and a_func.__closure__ is not None:
-        raise NonCompliantFunction(f"The function {name} can't be a closure,"
+        raise FunctionError(f"The function {name} can't be a closure,"
             " only regular functions are allowed.")
 
     if a_func.__name__ == "<lambda>":
-        raise NonCompliantFunction(f"The function {name} can't be lambda,"
+        raise FunctionError(f"The function {name} can't be lambda,"
             " only regular functions are allowed.")
 
     if accepts_unlimited_positional_args(a_func):
-        raise NonCompliantFunction("Pythagoras only allows functions "
+        raise FunctionError("Pythagoras only allows functions "
             f"with named arguments, but {name} accepts "
             "unlimited (nameless) positional arguments.")
 
     if inspect.iscoroutinefunction(a_func):
-        raise NonCompliantFunction(f"The function {name} can't be "
+        raise FunctionError(f"The function {name} can't be "
             "an async function, only regular functions are allowed.")
 
     if count_parameters_with_defaults(a_func) > 0:
-        raise NonCompliantFunction(f"The function {name} can't have "
+        raise FunctionError(f"The function {name} can't have "
             "default values for its parameters.")

pythagoras/_020_ordinary_code_portals/ordinary_decorator.py

@@ -20,7 +20,8 @@ class ordinary:
            portal: Optional OrdinaryCodePortal to link to the resulting
                OrdinaryFn wrappers.
        """
-       assert portal is None or isinstance(portal, OrdinaryCodePortal)
+       if not (portal is None or isinstance(portal, OrdinaryCodePortal)):
+           raise TypeError(f"portal must be an OrdinaryCodePortal or None, got {type(portal).__name__}")
        self._portal=portal
 
 

pythagoras/_020_ordinary_code_portals/ordinary_portal_core_classes.py

@@ -6,6 +6,7 @@ from typing import Callable, Any
 import pandas as pd
 from persidict import PersiDict
 
+from .exceptions import FunctionError
 from .._010_basic_portals import BasicPortal, PortalAwareClass
 from .code_normalizer import _get_normalized_function_source_impl
 from .function_processing import get_function_name_from_source
@@ -32,9 +33,9 @@ def get_normalized_function_source(a_func: OrdinaryFn | Callable | str) -> str:
         The normalized source code string.
 
     Raises:
-        NonCompliantFunction: If the function is not compliant with Pythagoras'
+        FunctionError: If the function is not compliant with Pythagoras'
             ordinarity rules or multiple decorators are present.
-        AssertionError: If input type is invalid or integrity checks fail.
+        TypeError | ValueError: If input type is invalid or integrity checks fail.
         SyntaxError: If the provided source cannot be parsed.
     """
 
@@ -45,7 +46,7 @@ def get_normalized_function_source(a_func: OrdinaryFn | Callable | str) -> str:
             a_func, drop_pth_decorators=True)
 
 
-REGISTERED_FUNCTIONS_TXT = "Registered functions"
+_REGISTERED_FUNCTIONS_TXT = "Registered functions"
 
 class OrdinaryCodePortal(BasicPortal):
     """Portal that manages OrdinaryFn instances and their runtime context.
@@ -136,7 +137,7 @@ class OrdinaryCodePortal(BasicPortal):
         all_params = [super().describe()]
 
         all_params.append(_describe_runtime_characteristic(
-            REGISTERED_FUNCTIONS_TXT, self.get_number_of_linked_functions()))
+            _REGISTERED_FUNCTIONS_TXT, self.get_number_of_linked_functions()))
 
         result = pd.concat(all_params)
         result.reset_index(drop=True, inplace=True)
@@ -182,7 +183,7 @@ class OrdinaryFn(PortalAwareClass):
 
         Raises:
             TypeError: If fn is neither callable, a string, nor an OrdinaryFn.
-            NonCompliantFunction: If the provided function source is not
+            FunctionError: If the provided function source is not
                 compliant with Pythagoras ordinarity rules.
             SyntaxError: If the provided source cannot be parsed.
         """
@@ -368,11 +369,12 @@ class OrdinaryFn(PortalAwareClass):
             Any: The result of executing the function.
 
         Raises:
-            AssertionError: If positional arguments are supplied.
+            TypeError: If positional arguments are supplied.
         """
-        assert len(args) == 0, (f"Function {self.name} can't"
-            + " be called with positional arguments,"
-            + " only keyword arguments are allowed.")
+        if len(args) != 0:
+            raise FunctionError(f"Function {self.name} can't be called"
+            f" with positional arguments, only keyword arguments are allowed."
+            f" Got {len(args)} positional args.")
         return self.execute(**kwargs)
 
 

pythagoras/_030_data_portals/data_portal_core_classes.py

@@ -17,8 +17,8 @@ from .._010_basic_portals.basic_portal_core_classes import (
 from .._020_ordinary_code_portals import OrdinaryCodePortal ,OrdinaryFn
 from persidict import WriteOnceDict
 
-TOTAL_VALUES_TXT = "Values, total"
-PROBABILITY_OF_CHECKS_TXT = "Probability of consistency checks"
+_TOTAL_VALUES_TXT = "Values, total"
+_PROBABILITY_OF_CHECKS_TXT = "Probability of consistency checks"
 
 
 def get_active_data_portal() -> DataPortal:
@@ -28,10 +28,11 @@ def get_active_data_portal() -> DataPortal:
         DataPortal: The portal that is active in the current context ("with" block).
 
     Raises:
-        AssertionError: If the active portal is not an instance of DataPortal.
+        TypeError: If the active portal is not an instance of DataPortal.
     """
     portal = get_active_portal()
-    assert isinstance(portal, DataPortal)
+    if not isinstance(portal, DataPortal):
+        raise TypeError(f"Active portal must be DataPortal, got {type(portal).__name__}")
     return portal
 
 
@@ -43,10 +44,12 @@ def get_nonactive_data_portals() -> list[DataPortal]:
             the runtime but are not the current active portal stack.
 
     Raises:
-        AssertionError: If any returned portal is not an instance of DataPortal.
+        TypeError: If any returned portal is not an instance of DataPortal.
     """
     portals = get_nonactive_portals()
-    assert all(isinstance(p, DataPortal) for p in portals)
+    if not all(isinstance(p, DataPortal) for p in portals):
+        bad = [type(p).__name__ for p in portals if not isinstance(p, DataPortal)]
+        raise TypeError(f"Expected all nonactive portals to be DataPortal, got invalid types: {bad}")
     return portals
 
 
@@ -211,9 +214,9 @@ class DataPortal(OrdinaryCodePortal):
         all_params = [super().describe()]
 
         all_params.append(_describe_persistent_characteristic(
-            TOTAL_VALUES_TXT, len(self._value_store)))
+            _TOTAL_VALUES_TXT, len(self._value_store)))
         all_params.append(_describe_runtime_characteristic(
-            PROBABILITY_OF_CHECKS_TXT, self.p_consistency_checks))
+            _PROBABILITY_OF_CHECKS_TXT, self.p_consistency_checks))
 
         result = pd.concat(all_params)
         result.reset_index(drop=True, inplace=True)
@@ -493,9 +496,8 @@ class ValueAddr(HashAddr):
                 , hash_signature=hash_signature)
             return
 
-        assert not isinstance(data, HashAddr), (
-                "get_ValueAddr is the only way to "
-                + "convert HashAddr into ValueAddr")
+        if isinstance(data, HashAddr):
+            raise TypeError("get_ValueAddr is the only way to convert HashAddr into ValueAddr")
 
         descriptor = self._build_descriptor(data)
         hash_signature = self._build_hash_signature(data)

pythagoras/_030_data_portals/storable_decorator.py

@@ -18,7 +18,9 @@ class storable(ordinary):
             portal: The DataPortal to use as default when wrapping functions.
                 If None, the active portal at call time will be used.
         """
-        assert isinstance(portal, DataPortal) or portal is None
+        if not (isinstance(portal, DataPortal) or portal is None):
+            raise TypeError(f"portal must be a DataPortal or None, "
+                            f"got {type(portal).__name__}")
         ordinary.__init__(self=self, portal=portal)
 
     def __call__(self,fn:Callable)->StorableFn:

pythagoras/_040_logging_code_portals/logging_decorator.py

@@ -27,8 +27,10 @@ class logging(storable):
             portal: Optional LoggingCodePortal to bind the wrapped function to.
                 If None, the active portal at execution time is used.
         """
-        assert isinstance(excessive_logging, (bool,Joker))
-        assert isinstance(portal, LoggingCodePortal) or portal is None
+        if not isinstance(excessive_logging, (bool, Joker)):
+            raise TypeError(f"excessive_logging must be bool or Joker, got {type(excessive_logging).__name__}")
+        if not (isinstance(portal, LoggingCodePortal) or portal is None):
+            raise TypeError(f"portal must be LoggingCodePortal or None, got {type(portal).__name__}")
         storable.__init__(self=self, portal=portal)
         self._excessive_logging = excessive_logging
 

pythagoras/_040_logging_code_portals/logging_portal_core_classes.py

@@ -159,7 +159,8 @@ class   LoggingFnCallSignature:
     _addr_cache: ValueAddr | None
 
     def __init__(self, fn:LoggingFn, arguments:dict):
-        assert isinstance(fn, LoggingFn)
+        if not isinstance(fn, LoggingFn):
+            raise TypeError(f"fn must be an instance of LoggingFn, got {type(fn).__name__}")
         isinstance(arguments, dict)
         arguments = KwArgs(**arguments)
         with fn.portal:
@@ -729,13 +730,13 @@ class LoggingFnExecutionFrame(NotPicklableClass):
         Returns:
             LoggingFnExecutionFrame: This frame instance for use as a context var.
         """
-        assert not self.context_used, (
-            "An instance of PureFnExecutionFrame can be used only once.")
+        if self.context_used:
+            raise RuntimeError(f"An instance of PureFnExecutionFrame can be used only once.")
         self.context_used = True
-        assert self.exception_counter == 0, (
-            "An instance of PureFnExecutionFrame can be used only once.")
-        assert self.event_counter == 0, (
-            "An instance of PureFnExecutionFrame can be used only once.")
+        if self.exception_counter != 0:
+            raise RuntimeError(f"An instance of PureFnExecutionFrame can be used only once.")
+        if self.event_counter != 0:
+            raise RuntimeError(f"An instance of PureFnExecutionFrame can be used only once.")
         self.portal.__enter__()
         if isinstance(self.output_capturer, OutputCapturer):
             self.output_capturer.__enter__()
@@ -797,9 +798,9 @@ class LoggingFnExecutionFrame(NotPicklableClass):
         LoggingFnExecutionFrame.call_stack.pop()
 
 
-EXCEPTIONS_TOTAL_TXT = "Exceptions, total"
-EXCEPTIONS_TODAY_TXT = "Exceptions, today"
-EXCESSIVE_LOGGING_TXT = "Excessive logging"
+_EXCEPTIONS_TOTAL_TXT = "Exceptions, total"
+_EXCEPTIONS_TODAY_TXT = "Exceptions, today"
+_EXCESSIVE_LOGGING_TXT = "Excessive logging"
 
 class LoggingCodePortal(DataPortal):
     """A portal that supports function-level logging for events and exceptions.
@@ -921,12 +922,12 @@ class LoggingCodePortal(DataPortal):
         """
         all_params = [super().describe()]
         all_params.append(_describe_persistent_characteristic(
-            EXCEPTIONS_TOTAL_TXT, len(self._crash_history)))
+            _EXCEPTIONS_TOTAL_TXT, len(self._crash_history)))
         all_params.append(_describe_persistent_characteristic(
-            EXCEPTIONS_TODAY_TXT
+            _EXCEPTIONS_TODAY_TXT
             , len(self._crash_history.get_subdict(current_date_gmt_string()))))
         all_params.append(_describe_runtime_characteristic(
-            EXCESSIVE_LOGGING_TXT, self.excessive_logging))
+            _EXCESSIVE_LOGGING_TXT, self.excessive_logging))
 
         result = pd.concat(all_params)
         result.reset_index(drop=True, inplace=True)

pythagoras/_050_safe_code_portals/safe_decorator.py

@@ -30,7 +30,8 @@ class safe(logging):
             portal: The SafeCodePortal to attach the resulting SafeFn to. If
                 None, the active portal (if any) may be used by lower layers.
         """
-        assert isinstance(portal, SafeCodePortal) or portal is None
+        if not (isinstance(portal, SafeCodePortal) or portal is None):
+            raise TypeError(f"portal must be a SafeCodePortal or None, got {type(portal).__name__}")
         logging.__init__(self=self
             , portal=portal
             , excessive_logging=excessive_logging)

pythagoras/_050_safe_code_portals/safe_portal_core_classes.py

@@ -72,8 +72,10 @@ class SafeFnCallSignature(LoggingFnCallSignature):
             fn: The safe function object to be called.
             arguments: The keyword arguments to use for the call.
         """
-        assert isinstance(fn, SafeFn)
-        assert isinstance(arguments, dict)
+        if not isinstance(fn, SafeFn):
+            raise TypeError(f"fn must be a SafeFn instance, got {type(fn).__name__}")
+        if not isinstance(arguments, dict):
+            raise TypeError(f"arguments must be a dict, got {type(arguments).__name__}")
         super().__init__(fn, arguments)
 
     @property

pythagoras/_060_autonomous_code_portals/autonomous_decorators.py

@@ -74,11 +74,13 @@ class autonomous(safe):
             portal: Portal instance to use for autonomy and safety checks.
 
         Raises:
-            AssertionError: If portal is not an AutonomousCodePortal or None, or
+            TypeError: If portal is not an AutonomousCodePortal or None, or
                 if fixed_kwargs is not a dict or None.
         """
-        assert isinstance(portal, AutonomousCodePortal) or portal is None
-        assert isinstance(fixed_kwargs, dict) or fixed_kwargs is None
+        if not (isinstance(portal, AutonomousCodePortal) or portal is None):
+            raise TypeError(f"portal must be an AutonomousCodePortal or None, got {type(portal).__name__}")
+        if not (isinstance(fixed_kwargs, dict) or fixed_kwargs is None):
+            raise TypeError(f"fixed_kwargs must be a dict or None, got {type(fixed_kwargs).__name__}")
         safe.__init__(self=self
             , portal=portal
             , excessive_logging=excessive_logging)

pythagoras/_060_autonomous_code_portals/autonomous_portal_core_classes.py

@@ -1,6 +1,8 @@
 from __future__ import annotations
 
 import builtins
+
+from .. import FunctionError
 from .._020_ordinary_code_portals.code_normalizer import _pythagoras_decorator_names
 from .._040_logging_code_portals import KwArgs
 
@@ -51,8 +53,10 @@ class AutonomousFnCallSignature(SafeFnCallSignature):
             fn: The autonomous function being called.
             arguments: The call-time arguments mapping (already validated).
         """
-        assert isinstance(fn, AutonomousFn)
-        assert isinstance(arguments, dict)
+        if not isinstance(fn, AutonomousFn):
+            raise TypeError(f"fn must be AutonomousFn, got {type(fn).__name__}")
+        if not isinstance(arguments, dict):
+            raise TypeError(f"arguments must be dict, got {type(arguments).__name__}")
         super().__init__(fn, arguments)
 
     @property
@@ -87,7 +91,7 @@ class AutonomousFn(SafeFn):
             portal: AutonomousCodePortal to use; may be None to defer.
 
         Raises:
-            AssertionError: If static analysis detects violations of autonomy
+            FunctionError: If static analysis detects violations of autonomy
                 (nonlocal/global unbound names, missing imports, or yield usage).
         """
         super().__init__(fn=fn
@@ -110,19 +114,20 @@ class AutonomousFn(SafeFn):
         analyzer = analyze_names_in_function(self.source_code)
         normalized_source = analyzer["normalized_source"]
         analyzer = analyzer["analyzer"]
-        assert self.source_code == normalized_source
+        if self.source_code != normalized_source:
+            raise RuntimeError("Normalized source does not match original source for autonomous function")
 
         nonlocal_names = analyzer.names.explicitly_nonlocal_unbound_deep
         all_decorators = _pythagoras_decorator_names
         # all_decorators = sys.modules["pythagoras"].all_decorators
         nonlocal_names -= set(all_decorators) #????????????
 
-        assert len(nonlocal_names) == 0, (f"Function {self.name}"
-            + f" is not autonomous, it uses external nonlocal"
-            + f" objects: {analyzer.names.explicitly_nonlocal_unbound_deep}")
+        if len(nonlocal_names) != 0:
+            raise FunctionError(
+                f"Function {self.name} is not autonomous, it uses external nonlocal objects: {analyzer.names.explicitly_nonlocal_unbound_deep}")
 
-        assert analyzer.n_yelds == 0, (f"Function {self.name}"
-            + f" is not autonomous, it uses yield statements")
+        if analyzer.n_yelds != 0:
+            raise FunctionError(f"Function {self.name} is not autonomous, it uses yield statements")
 
         import_required = analyzer.names.explicitly_global_unbound_deep
         import_required |= analyzer.names.unclassified_deep
@@ -134,10 +139,9 @@ class AutonomousFn(SafeFn):
         import_required -= pth_names
         import_required -= {fn_name}
 
-        assert len(import_required) == 0, (f"Function {self.name}"
-            + f" is not autonomous, it uses global"
-            + f" objects {import_required}"
-            + f" without importing them inside the function body")
+        if len(import_required) != 0:
+            raise FunctionError(
+                f"Function {self.name} is not autonomous, it uses global objects {import_required} without importing them inside the function body")
 
 
     @property
@@ -165,11 +169,12 @@ class AutonomousFn(SafeFn):
             Any: Result of the wrapped function call.
 
         Raises:
-            AssertionError: If provided kwargs overlap with fixed kwargs.
+            ValueError: If provided kwargs overlap with fixed kwargs.
         """
         with self.portal:
             overlapping_keys = set(kwargs.keys()) & set(self.fixed_kwargs.keys())
-            assert len(overlapping_keys) == 0
+            if len(overlapping_keys) != 0:
+                raise ValueError(f"Overlapping kwargs with fixed kwargs: {sorted(overlapping_keys)}")
             kwargs.update(self.fixed_kwargs)
             return super().execute(**kwargs)
 
@@ -200,12 +205,13 @@ class AutonomousFn(SafeFn):
             keyword arguments in addition to already fixed ones.
 
         Raises:
-            AssertionError: If any of the provided kwargs overlap with already
+            ValueError: If any of the provided kwargs overlap with already
                 fixed kwargs.
         """
 
         overlapping_keys = set(kwargs.keys()) & set(self.fixed_kwargs.keys())
-        assert len(overlapping_keys) == 0
+        if len(overlapping_keys) != 0:
+            raise ValueError(f"Overlapping kwargs with fixed kwargs: {sorted(overlapping_keys)}")
         new_fixed_kwargs = {**self.fixed_kwargs,**kwargs}
         new_fn = type(self)(fn=self, fixed_kwargs=new_fixed_kwargs)
         return new_fn

pythagoras/_060_autonomous_code_portals/names_usage_analyzer.py

@@ -279,7 +279,7 @@ def analyze_names_in_function(
             - normalized_source (str): The normalized source code.
 
     Raises:
-        AssertionError: If the input is not a single regular function (e.g., a
+        ValueError: If the input is not a single regular function (e.g., a
             lambda, async function, callable class, or multiple definitions).
     """
 
@@ -289,21 +289,24 @@ def analyze_names_in_function(
     while lines[line_num].startswith("@"):
         line_num+=1
 
-    assert lines[line_num].startswith("def "),("This action can only"
-            + " be applied to conventional functions,"
-            + " not to instances of callable classes, "
-            + " not to lambda functions, "
-            + " not to async functions.")
+    if not lines[line_num].startswith("def "):
+        raise ValueError(
+            "This action can only be applied to conventional functions, "
+            "not to instances of callable classes, not to lambda functions, "
+            "not to async functions.")
     tree = ast.parse(normalized_source)
-    assert isinstance(tree, ast.Module), (f"Only one high lever"
-            + f" function definition is allowed to be processed."
-            + f" The following code is not allowed: {normalized_source}")
-    assert isinstance(tree.body[0], ast.FunctionDef), (f"Only one high lever"
-            + f" function definition is allowed to be processed."
-            + f" The following code is not allowed: {normalized_source}")
-    assert len(tree.body)==1, (f"Only one high lever"
-            + f" function definition is allowed to be processed."
-            + f" The following code is not allowed: {normalized_source}")
+    if not isinstance(tree, ast.Module):
+        raise ValueError(
+            f"Only one high level function definition is allowed to be processed. "
+            f"The following code is not allowed: {normalized_source}")
+    if not isinstance(tree.body[0], ast.FunctionDef):
+        raise ValueError(
+            f"Only one high level function definition is allowed to be processed. "
+            f"The following code is not allowed: {normalized_source}")
+    if len(tree.body) != 1:
+        raise ValueError(
+            f"Only one high level function definition is allowed to be processed. "
+            f"The following code is not allowed: {normalized_source}")
     analyzer = NamesUsageAnalyzer()
     analyzer.visit(tree)
     result = dict(tree=tree, analyzer=analyzer

pythagoras/_070_protected_code_portals/protected_decorators.py

@@ -68,8 +68,10 @@ class protected(autonomous):
                 bind the wrapped function to. If None, a suitable portal will be
                 inferred when fuction is called.
         """
-        assert isinstance(portal, ProtectedCodePortal) or portal is None
-        assert isinstance(fixed_kwargs, dict) or fixed_kwargs is None
+        if not (isinstance(portal, ProtectedCodePortal) or portal is None):
+            raise TypeError(f"portal must be a ProtectedCodePortal or None, got {type(portal).__name__}")
+        if not (isinstance(fixed_kwargs, dict) or fixed_kwargs is None):
+            raise TypeError(f"fixed_kwargs must be a dict or None, got {type(fixed_kwargs).__name__}")
         autonomous.__init__(self=self
             , portal=portal
             , excessive_logging=excessive_logging

pythagoras/_070_protected_code_portals/protected_portal_core_classes.py

@@ -280,7 +280,7 @@ class ProtectedFn(AutonomousFn):
                 elif validation_result is None:
                     assert False, (f"Pre-validators failed for function {self.name}")
                 result = super().execute(**kwargs)
-                assert self.validate_execution_result(kw_args, result)
+                assert (self.validate_execution_result(kw_args, result) is VALIDATION_SUCCESSFUL)
                 return result
 
 
@@ -306,7 +306,8 @@ class ProtectedFn(AutonomousFn):
         Raises:
             TypeError: If an unexpected validator_type is provided.
         """
-        assert validator_type in {PreValidatorFn, PostValidatorFn}
+        if validator_type not in {PreValidatorFn, PostValidatorFn}:
+            raise TypeError(f"validator_type must be PreValidatorFn or PostValidatorFn, got {validator_type}")
         if validators is None:
             return []
         if not isinstance(validators, list):
@@ -314,7 +315,8 @@ class ProtectedFn(AutonomousFn):
                     or isinstance(validators, ValidatorFn)
                     or isinstance(validators, str)):
                 validators = [validators]
-        assert isinstance(validators, list)
+        if not isinstance(validators, list):
+            raise TypeError(f"validators must be a list or compatible item(s); got type {type(validators).__name__}")
         validators = flatten_list(validators)
         new_validators = []
         for validator in validators:
@@ -394,8 +396,10 @@ class ProtectedFnCallSignature(AutonomousFnCallSignature):
             fn (ProtectedFn): The protected function to call.
             arguments (dict): Keyword arguments to be passed at execution time.
         """
-        assert isinstance(fn, ProtectedFn)
-        assert isinstance(arguments, dict)
+        if not isinstance(fn, ProtectedFn):
+            raise TypeError(f"fn must be a ProtectedFn instance, got {type(fn).__name__}")
+        if not isinstance(arguments, dict):
+            raise TypeError(f"arguments must be a dict, got {type(arguments).__name__}")
         super().__init__(fn, arguments)
 
     @property
@@ -446,8 +450,8 @@ class ValidatorFn(AutonomousFn):
         raise NotImplementedError("This method must be overridden")
 
 
-    def execute(self,**kwargs) \
-            -> ProtectedFnCallSignature | ValidationSuccessFlag | None:
+    def execute(self,**kwargs
+                ) -> ProtectedFnCallSignature | ValidationSuccessFlag | None:
         """Execute the validator after verifying keyword arguments.
 
         Args:
@@ -457,7 +461,10 @@ class ValidatorFn(AutonomousFn):
             ProtectedFnCallSignature | ValidationSuccessFlag | None: Depending
             on the validator type and outcome.
         """
-        assert set(kwargs) == self.get_allowed_kwargs_names()
+        expected = self.get_allowed_kwargs_names()
+        provided = set(kwargs)
+        if provided != expected:
+            raise ValueError(f"Invalid kwargs for {type(self).__name__}: expected {sorted(expected)}, got {sorted(provided)}")
         return super().execute(**kwargs)
 
 

pythagoras/_080_pure_code_portals/pure_core_classes.py

@@ -47,8 +47,8 @@ ASupportingFunc:TypeAlias = str | AutonomousFn
 
 SupportingFuncs:TypeAlias = ASupportingFunc | List[ASupportingFunc] | None
 
-CACHED_EXECUTION_RESULTS_TXT = "Cached execution results"
-EXECUTION_QUEUE_SIZE_TXT = "Execution queue size"
+_CACHED_EXECUTION_RESULTS_TXT = "Cached execution results"
+_EXECUTION_QUEUE_SIZE_TXT = "Execution queue size"
 
 class PureCodePortal(ProtectedCodePortal):
     """Portal that manages execution and caching for pure functions.
@@ -113,9 +113,9 @@ class PureCodePortal(ProtectedCodePortal):
         all_params = [super().describe()]
 
         all_params.append(_describe_persistent_characteristic(
-            CACHED_EXECUTION_RESULTS_TXT, len(self._execution_results)))
+            _CACHED_EXECUTION_RESULTS_TXT, len(self._execution_results)))
         all_params.append(_describe_persistent_characteristic(
-            EXECUTION_QUEUE_SIZE_TXT, len(self._execution_requests)))
+            _EXECUTION_QUEUE_SIZE_TXT, len(self._execution_requests)))
 
         result = pd.concat(all_params)
         result.reset_index(drop=True, inplace=True)
@@ -140,8 +140,10 @@ class PureFnCallSignature(ProtectedFnCallSignature):
             fn: The pure function being called.
             arguments: Keyword arguments for the call.
         """
-        assert isinstance(fn, PureFn)
-        assert isinstance(arguments, dict)
+        if not isinstance(fn, PureFn):
+            raise TypeError(f"fn must be a PureFn instance, got {type(fn).__name__}")
+        if not isinstance(arguments, dict):
+            raise TypeError(f"arguments must be a dict, got {type(arguments).__name__}")
         super().__init__(fn, arguments)
 
     @property
@@ -314,9 +316,11 @@ class PureFn(ProtectedFn):
             list[PureFnExecutionResultAddr]: Addresses for all requested
             executions, in the same order as the input list.
         """
-        assert isinstance(list_of_kwargs, (list, tuple))
+        if not isinstance(list_of_kwargs, (list, tuple)):
+            raise TypeError(f"list_of_kwargs must be a list or tuple, got {type(list_of_kwargs).__name__}")
         for kwargs in list_of_kwargs:
-            assert isinstance(kwargs, dict)
+            if not isinstance(kwargs, dict):
+                raise TypeError(f"Each item in list_of_kwargs must be a dict, got {type(kwargs).__name__}")
         with self.portal:
             list_to_return = []
             list_to_swarm = []
@@ -411,7 +415,8 @@ class PureFnExecutionResultAddr(HashAddr):
             fn: The PureFn whose execution result is addressed.
             arguments: The keyword arguments for the call (packed dict).
         """
-        assert isinstance(fn, PureFn)
+        if not isinstance(fn, PureFn):
+            raise TypeError(f"fn must be a PureFn instance, got {type(fn).__name__}")
         with fn.portal as portal:
             self._kwargs_cache = KwArgs(**arguments)
             self._fn_cache = fn
@@ -530,7 +535,8 @@ class PureFnExecutionResultAddr(HashAddr):
             be imported from a known non-active portal); False otherwise.
         """
         if hasattr(self, "_ready_cache"):
-            assert self._ready_cache
+            if not self._ready_cache:
+                raise RuntimeError(f"Internal inconsistency: _ready_cache is set but False for address {self}")
             return True
         with self.fn.portal:
             if self._ready_in_active_portal:
@@ -608,7 +614,8 @@ class PureFnExecutionResultAddr(HashAddr):
             TimeoutError: If the timeout elapses before the value becomes
                 available.
         """
-        assert timeout is None or timeout >= 0
+        if timeout is not None and timeout < 0:
+            raise ValueError(f"timeout must be None or non-negative, got {timeout}")
         if hasattr(self, "_result_cache"):
             return self._result_cache
 
@@ -672,8 +679,8 @@ class PureFnExecutionResultAddr(HashAddr):
         process is currently working on it, or if there were too many
         past attempts to execute it. Otherwise, returns True.
         """
-        DEFAULT_EXECUTION_TIME = 10 #TODO: move to portal config
-        MAX_EXECUTION_ATTEMPTS = 5
+        _DEFAULT_EXECUTION_TIME = 10 #TODO: move to portal config
+        _MAX_EXECUTION_ATTEMPTS = 5
         # TODO: these should not be constants
         if self.ready:
             return False
@@ -682,13 +689,13 @@ class PureFnExecutionResultAddr(HashAddr):
             n_past_attempts = len(past_attempts)
             if n_past_attempts == 0:
                 return True
-            if n_past_attempts > MAX_EXECUTION_ATTEMPTS:
+            if n_past_attempts > _MAX_EXECUTION_ATTEMPTS:
                 #TODO: log this event. Should we have DLQ?
                 return False
             most_recent_timestamp = max(
                 past_attempts.timestamp(a) for a in past_attempts)
             current_timestamp = time.time()
             if (current_timestamp - most_recent_timestamp
-                    > DEFAULT_EXECUTION_TIME*(2**n_past_attempts)):
+                    > _DEFAULT_EXECUTION_TIME*(2**n_past_attempts)):
                 return True
             return False

pythagoras/_080_pure_code_portals/recursion_pre_validator.py

@@ -42,11 +42,14 @@ def _recursion_pre_validator(
         protected execution pipeline.
     """
     unpacked_kwargs = packed_kwargs.unpack()
-    assert param_name in unpacked_kwargs
+    if param_name not in unpacked_kwargs:
+        raise KeyError(f"Missing required parameter '{param_name}' in kwargs")
     fn = fn_addr.get()
     param_value = unpacked_kwargs[param_name]
-    assert isinstance(param_value, int)
-    assert param_value >= 0
+    if not isinstance(param_value, int):
+        raise TypeError(f"Parameter '{param_name}' must be int, got {type(param_value).__name__}")
+    if param_value < 0:
+        raise ValueError(f"Parameter '{param_name}' must be non-negative, got {param_value}")
     if param_value in {0,1}:
         return pth.VALIDATION_SUCCESSFUL
     
@@ -90,7 +93,8 @@ def recursive_parameters(
     """
     result = []
     for name in args:
-        assert isinstance(name, str)
+        if not isinstance(name, str):
+            raise TypeError(f"recursive parameter names must be strings, got {type(name).__name__}")
         validator =  ComplexPreValidatorFn(
             _recursion_pre_validator, fixed_kwargs=dict(param_name=name))
         result.append(validator)

pythagoras/_090_swarming_portals/swarming_portals.py

@@ -41,7 +41,7 @@ from multiprocessing import get_context
 from .._090_swarming_portals.output_suppressor import (
     OutputSuppressor)
 
-BACKGROUND_WORKERS_TXT = "Background workers"
+_BACKGROUND_WORKERS_TXT = "Background workers"
 
 
 class SwarmingPortal(PureCodePortal):
@@ -115,15 +115,17 @@ class SwarmingPortal(PureCodePortal):
             , p_consistency_checks=p_consistency_checks
             , excessive_logging=excessive_logging)
 
-        assert isinstance(max_n_workers, (int, Joker))
+        if not isinstance(max_n_workers, (int, Joker)):
+            raise TypeError(f"max_n_workers must be int or Joker, got {type(max_n_workers).__name__}")
 
-        if parent_process_id is None or parent_process_start_time is None:
-            assert parent_process_id is None
-            assert parent_process_start_time is None
-            self._auxiliary_config_params_at_init["max_n_workers"
-                ] = max_n_workers
+        if (parent_process_id is None) != (parent_process_start_time is None):
+            raise RuntimeError(
+                f"parent_process_id and parent_process_start_time must both be None or both set; got id={parent_process_id}, start_time={parent_process_start_time}")
+        if parent_process_id is None:
+            self._auxiliary_config_params_at_init["max_n_workers"] = max_n_workers
         else:
-            assert max_n_workers == 0
+            if max_n_workers != 0:
+                raise ValueError(f"In child context, max_n_workers must be 0, got {max_n_workers}")
 
         compute_nodes_prototype = self._root_dict.get_subdict("compute_nodes")
         compute_nodes_shared_params = compute_nodes_prototype.get_params()
@@ -262,7 +264,7 @@ class SwarmingPortal(PureCodePortal):
         """
         all_params = [super().describe()]
         all_params.append(_describe_runtime_characteristic(
-            BACKGROUND_WORKERS_TXT, self.max_n_workers))
+            _BACKGROUND_WORKERS_TXT, self.max_n_workers))
 
         result = pd.concat(all_params)
         result.reset_index(drop=True, inplace=True)
@@ -353,8 +355,8 @@ def _launch_many_background_workers(portal_init_jsparams:JsonSerializedObject) -
         parent_process_start_time = get_current_process_start_time())
 
     portal = parameterizable.loadjs(portal_init_jsparams)
-    assert isinstance(portal, SwarmingPortal)
-
+    if not isinstance(portal, SwarmingPortal):
+        raise TypeError(f"Expected SwarmingPortal, got {type(portal).__name__}")
     summary = build_execution_environment_summary()
     portal._compute_nodes.json[portal._execution_environment_address] = summary
 
@@ -402,7 +404,8 @@ def _background_worker(portal_init_jsparams:JsonSerializedObject) -> None:
             reconstructing a SwarmingPortal in child context.
     """
     portal = parameterizable.loadjs(portal_init_jsparams)
-    assert isinstance(portal, SwarmingPortal)
+    if not isinstance(portal, SwarmingPortal):
+        raise TypeError(f"Expected SwarmingPortal, got {type(portal).__name__}")
     with portal:
         ctx = get_context("spawn")
         with OutputSuppressor():
@@ -433,7 +436,8 @@ def _process_random_execution_request(portal_init_jsparams:JsonSerializedObject)
     portal_init_jsparams = update_jsparams(
         portal_init_jsparams, max_n_workers=0)
     portal = parameterizable.loadjs(portal_init_jsparams)
-    assert isinstance(portal, SwarmingPortal)
+    if not isinstance(portal, SwarmingPortal):
+        raise TypeError(f"Expected SwarmingPortal, got {type(portal).__name__}")
     with portal:
         call_signature:PureFnCallSignature|None = None
         while True:

{pythagoras-0.24.8.dist-info → pythagoras-0.24.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pythagoras
-Version: 0.24.8
+Version: 0.24.10
 Summary: Planet-scale distributed computing in Python.
 Keywords: cloud,ML,AI,serverless,distributed,parallel,machine-learning,deep-learning,pythagoras
 Author: Volodymyr (Vlad) Pavlov

{pythagoras-0.24.8.dist-info → pythagoras-0.24.10.dist-info}/RECORD

@@ -1,51 +1,51 @@
 pythagoras/.DS_Store,sha256=4fJ-j5kHYgNLz5ki6QI2jkwoTuthfKswojnfe4naJ8U,8196
-pythagoras/_010_basic_portals/__init__.py,sha256=L6vahRANApOIIdzw3wuAIZtJRijepneOevXnlhrZmj4,1668
-pythagoras/_010_basic_portals/basic_portal_core_classes.py,sha256=UcvgxajJdtb7bgNkhUrehjN6Hd39iCNFtVqeC71qYoU,23979
-pythagoras/_010_basic_portals/exceptions.py,sha256=CMtSyRb47YKZtANN-iCQBvvyYPKdKqomLygRE1fjSNk,1248
+pythagoras/_010_basic_portals/__init__.py,sha256=fX7p16EhJErnO2uN4HIu-F1OdfmZ24IMc0qBg9hXgrw,1642
+pythagoras/_010_basic_portals/basic_portal_core_classes.py,sha256=6ogcdLWuEG9KRgBBW2nXoN-6_sj2Yvj9trPcmx0E7xA,24709
 pythagoras/_010_basic_portals/long_infoname.py,sha256=KXOmHfQ_5hdZNqfB3Cif2CQiZ3XI3UAOEXKl3DLLYF4,1366
-pythagoras/_010_basic_portals/portal_tester.py,sha256=x6HiJ3GW9XWplnsT6Ob7QCy2J_JPgGpdaJ8QRyFH-e8,3353
+pythagoras/_010_basic_portals/portal_tester.py,sha256=icm9ZsmYg3l0DAKC3l4vkCB76jthHWyR_8D9aiSVkuQ,3452
 pythagoras/_010_basic_portals/post_init_metaclass.py,sha256=94FEVMCJBUReRb-fo2-LW8YWXUXw5lLLYlXMnlxHJuU,1495
-pythagoras/_020_ordinary_code_portals/__init__.py,sha256=p3kSqaQYj0xlhk9BwptFgA1USdTbfHkAB5Q9MH-ANI0,1295
-pythagoras/_020_ordinary_code_portals/code_normalizer.py,sha256=GJXvBX85W230OcwNAg8XXHAE4m39Q70piJ9g2jcIr4Q,6616
-pythagoras/_020_ordinary_code_portals/function_processing.py,sha256=b9Y4vNf1KSRkpUfS9UmWj3N_CNuPDgUMXdnR3IeyAoM,5021
-pythagoras/_020_ordinary_code_portals/ordinary_decorator.py,sha256=ETmy-HKRzCJfzTPOI-gelQT2tlJpVLRu4I85yv02vuo,1437
-pythagoras/_020_ordinary_code_portals/ordinary_portal_core_classes.py,sha256=C5nobGkYZBi2IHc1Pjfxjx_8h_ajF3Sf9Jq3yxFIR68,15963
+pythagoras/_020_ordinary_code_portals/__init__.py,sha256=z0-HUn9IWmL0c1FOmFlMzk0THBYwJuDw6FXpV8YeGUM,1321
+pythagoras/_020_ordinary_code_portals/code_normalizer.py,sha256=vqZ93CXeHBAgiQe_0LZ7qRZ4eT4ZSZit04DjkDWTgGw,6973
+pythagoras/_020_ordinary_code_portals/exceptions.py,sha256=hYvvXXANTRFKnRKGrOFZjIgwDwRXaUA9pxUmOSAOyog,274
+pythagoras/_020_ordinary_code_portals/function_processing.py,sha256=ZlA9yVmZTa6Q_LxDoZidK8QJZkrqiFnX89xu45LwJ44,4931
+pythagoras/_020_ordinary_code_portals/ordinary_decorator.py,sha256=O0WGZYMKtrf2oT8j7GYsrmkQ7PYjiDfTQrJxpjdzSkA,1545
+pythagoras/_020_ordinary_code_portals/ordinary_portal_core_classes.py,sha256=6QkaBj0gigA7n0xW70KzSmo5Bt8tY_UpmQE5g1lHMLU,16050
 pythagoras/_030_data_portals/__init__.py,sha256=f_F9DCmuVgPMgzwRjuNj6FI63S3oXu7lj3zU66Nw7Hc,1427
-pythagoras/_030_data_portals/data_portal_core_classes.py,sha256=D_Zg-q15II7IwweEGdBAMhGt09DYN_v_G0XFb5K3WB4,22459
+pythagoras/_030_data_portals/data_portal_core_classes.py,sha256=mGOX2OLPiEXyIuBMR66IM1lVZS32Q0Q4NxbFwqPWeGc,22711
 pythagoras/_030_data_portals/ready_and_get.py,sha256=lgkDygF4lFnZXcCvP5dmvzQX64wrZ8AnYJTI7v2ppng,4172
-pythagoras/_030_data_portals/storable_decorator.py,sha256=u70K8J44NTlofc4HmKHtxxbwKdUkBz6BDsIWds4dALQ,1160
+pythagoras/_030_data_portals/storable_decorator.py,sha256=zoJec_HBHFI5PBrF1khkPjaiviKTgdglr2F5HB42ySE,1292
 pythagoras/_040_logging_code_portals/__init__.py,sha256=q2hVyOVgE-9Ru3ycilK98YS9Rat8tSc6erd7AtGxpaA,996
 pythagoras/_040_logging_code_portals/exception_processing_tracking.py,sha256=DH1eeJAeVL6Fn-6sXBqx3Ocu2RXxVhLqdH1mvhM24VY,1850
 pythagoras/_040_logging_code_portals/execution_environment_summary.py,sha256=-0ynNibGfRh3J1Sq-N9j7eN1FlGvetEBiW0L4K_qJ30,3813
 pythagoras/_040_logging_code_portals/kw_args.py,sha256=j3Iao80gTBjPx6dk1Azd9D8pcdQ3QdfpkQtQq-4ATV0,4954
-pythagoras/_040_logging_code_portals/logging_decorator.py,sha256=-BGduV2U5SJ40qW8afRCUMrzYv5Pf_CgB4HlSEGDmlA,1766
-pythagoras/_040_logging_code_portals/logging_portal_core_classes.py,sha256=PPtYlI9PB9N3A8WrC5HrLD7MijofZWqUpaQgbwOqEN4,35094
+pythagoras/_040_logging_code_portals/logging_decorator.py,sha256=byYawCcdu8fOYrz30faLuq3XlhPOSypC6YcUpuBlAyc,1985
+pythagoras/_040_logging_code_portals/logging_portal_core_classes.py,sha256=nCYWp7u40kiek70i-l5uawZOaRQko1kJJweOdBQtzxk,35232
 pythagoras/_040_logging_code_portals/notebook_checker.py,sha256=qO7zfMC20hM4tSxlqB7gy6WI4imWX4Xl7ojSwgeVu0A,871
 pythagoras/_040_logging_code_portals/output_capturer.py,sha256=ohCp6qqxL7IuJGfnFuCIgj5Oc4HmC8c7uZGE_uzWkZk,4216
 pythagoras/_040_logging_code_portals/uncaught_exceptions.py,sha256=vQrY1mOYdAeKaCmCCY1MUy4xoXurQkfwQuDA43giPl0,4564
 pythagoras/_050_safe_code_portals/__init__.py,sha256=YR-V6W2WZ17SjqmTyY2xdY16xTVEEuLs2MddJj_WCZU,557
-pythagoras/_050_safe_code_portals/safe_decorator.py,sha256=AYvX7-km2reRMZ55ndO_2IS2SfHbnpyFv79AVwGg7Po,1681
-pythagoras/_050_safe_code_portals/safe_portal_core_classes.py,sha256=naY4R91N5bcCq8C_-YeBqhrr6UG8zkEQ5t8C3O8ytOw,5673
+pythagoras/_050_safe_code_portals/safe_decorator.py,sha256=F0d_UXuiF0S7FGYYmjkBgIuSd5iBNn6Ty7CrHV65_4I,1785
+pythagoras/_050_safe_code_portals/safe_portal_core_classes.py,sha256=1qMwR5RC4jzQVrcZ92ywHiDfCTFVzwPYZdPV1wH3a08,5850
 pythagoras/_060_autonomous_code_portals/__init__.py,sha256=hnv_dxxRx8c7IDf1QgVYHfYoeVAz8oD9K0oWI_o9N20,1704
-pythagoras/_060_autonomous_code_portals/autonomous_decorators.py,sha256=RFNHplYQR9L2w7YxDu7A2nqpvkReAF9cEU-76neXkNQ,4155
-pythagoras/_060_autonomous_code_portals/autonomous_portal_core_classes.py,sha256=Nj4TPML94eS0WThoOfaqZhlPJu6RttvDg69VT86WPlg,9881
-pythagoras/_060_autonomous_code_portals/names_usage_analyzer.py,sha256=arfAuFBY4Dx9Zmf0b3x-axrd35QY2Kg_2jHJC8ek3p8,11977
+pythagoras/_060_autonomous_code_portals/autonomous_decorators.py,sha256=wJ4Dm0Vnvfv_TlwJKTBrLfistAH2V85zk9xxOF0NWk0,4367
+pythagoras/_060_autonomous_code_portals/autonomous_portal_core_classes.py,sha256=1T5zcujRz3scWlzV6OGwK7GZJpNf-mvFILjOuw6Q4rk,10377
+pythagoras/_060_autonomous_code_portals/names_usage_analyzer.py,sha256=CZzYo3vII3JdpPoAP9Rny3lYiK48zuw981A76NWGblQ,12020
 pythagoras/_070_protected_code_portals/__init__.py,sha256=TvGcJaz20Qqsmv8m2pA4duBtFn_CdCKfkSbOSFoJS8k,989
 pythagoras/_070_protected_code_portals/basic_pre_validators.py,sha256=N5E1Gz_ULafZ8RQ1MvCQ6y29rfRVTQw7NZTqZ-pMOPo,6570
 pythagoras/_070_protected_code_portals/fn_arg_names_checker.py,sha256=HZJVhdyX2xNw0e7S9Wyz0jDun-5xBuhM71Tw2zHbYXc,1603
 pythagoras/_070_protected_code_portals/list_flattener.py,sha256=9V1Xj_y5nOCXS2V9mcBFX6UsyDdOR108SBqxbC-Ziyk,1604
 pythagoras/_070_protected_code_portals/package_manager.py,sha256=KbvEGfeKQsWIz0UogVUHfW6enbBmnqo1OjJz1xMTL4o,5437
-pythagoras/_070_protected_code_portals/protected_decorators.py,sha256=BrVcFiMHR4nD_dZgmlGkkMi-7ee3FqYFRCwl_nT35-E,4221
-pythagoras/_070_protected_code_portals/protected_portal_core_classes.py,sha256=nclgUd02KySQ1ffFSvLWMbonGcbq0SpJy2x3jLw5sAU,23419
+pythagoras/_070_protected_code_portals/protected_decorators.py,sha256=U3rz4qab9XvcVBPMeS85GOpysERBpIGRnNRXTX-YUxc,4436
+pythagoras/_070_protected_code_portals/protected_portal_core_classes.py,sha256=oygVKoXPVci8OhpiBAvgT1Uemj3COQSTx8-BUhdHQbg,24042
 pythagoras/_070_protected_code_portals/system_utils.py,sha256=Uv111FaO33xAA9wZ2iwtW8Gf-FXJBP2ld1sMBmvsHdo,5124
 pythagoras/_070_protected_code_portals/validation_succesful_const.py,sha256=DrM-Mf6dDLFJ7AmfzntD39Z23YMFfF6am78XU54AlnM,577
 pythagoras/_080_pure_code_portals/__init__.py,sha256=m9fC8hK4ve5VOJJKywAbUcyZJ9v5KiovI0O-HsXZHCg,1302
-pythagoras/_080_pure_code_portals/pure_core_classes.py,sha256=GniCEvJtEwYsqIxtz0QVh8wcgTHoisVuBKkIJKkz144,26381
+pythagoras/_080_pure_code_portals/pure_core_classes.py,sha256=6UjCU28hDWD1CFeyzl9wFAWtRHc1Hea7yiCxV6-JLaI,27070
 pythagoras/_080_pure_code_portals/pure_decorator.py,sha256=rmvtw_RpTbLjPTfy_2rdjfNSvV735hzTV_9q3drQKew,4036
-pythagoras/_080_pure_code_portals/recursion_pre_validator.py,sha256=qrVBK0U6YM08tQ4rsTlKNkGbqmF3Wj2yGrnWLCAP7BY,3461
+pythagoras/_080_pure_code_portals/recursion_pre_validator.py,sha256=Wb8ZcAO1xlfOUci8EEklToF54Uqmwya6EKmk7DVYcOg,3833
 pythagoras/_090_swarming_portals/__init__.py,sha256=TuA17PftTBudptAblNtBlD46BqUiitksOtf3y01QKm0,514
 pythagoras/_090_swarming_portals/output_suppressor.py,sha256=IspRrfLt6pI9iuD8I1dfpnQLpRi5sO11pP5QvIGVoMo,1581
-pythagoras/_090_swarming_portals/swarming_portals.py,sha256=aLHo8iFjEmd-3psFOkiYg9vCKApUD_Wv0-poxQEFu1U,19624
+pythagoras/_090_swarming_portals/swarming_portals.py,sha256=Dx9aUnfqlb_rSd2YORiImmuTgbPEMITGRJ6JPQts45E,20197
 pythagoras/_100_top_level_API/__init__.py,sha256=Jt6VWVCBygqnwl7_-s-jhdYp6masO_SuM2xQP4a96tk,505
 pythagoras/_100_top_level_API/default_local_portal.py,sha256=SnykTpTXg1KuT1qwDnrAZ63lYshMy-0nNiUgoOVMxCs,339
 pythagoras/_100_top_level_API/top_level_API.py,sha256=S2NXW4bfL98o6Txn6NM0EeBb1nzwFtPSl-yWNevAQIE,906
@@ -59,6 +59,6 @@ pythagoras/_900_project_stats_collector/__init__.py,sha256=Eagt-BhPPtBGgpMywx2lk
 pythagoras/_900_project_stats_collector/project_analyzer.py,sha256=uhycFKjUIXEpYcZYnak3yn4JFhchl-oZ7wt6spFxhoY,3574
 pythagoras/__init__.py,sha256=TMPtJdSi_WShCpJnsVVdO48Wcvs78GMbUi5gHc1eMLw,1233
 pythagoras/core/__init__.py,sha256=yfamQZNt_7FL7vfxSoCTZq2ZL6rupp6qzcp9CHhTj3E,2674
-pythagoras-0.24.8.dist-info/WHEEL,sha256=X16MKk8bp2DRsAuyteHJ-9qOjzmnY0x1aj0P1ftqqWA,78
-pythagoras-0.24.8.dist-info/METADATA,sha256=yrcNe2LC_-vrLl3BsyPGTyPOJPjmjBMByp2JqDjXpZ4,7467
-pythagoras-0.24.8.dist-info/RECORD,,
+pythagoras-0.24.10.dist-info/WHEEL,sha256=X16MKk8bp2DRsAuyteHJ-9qOjzmnY0x1aj0P1ftqqWA,78
+pythagoras-0.24.10.dist-info/METADATA,sha256=xImNZyZ7Laa9pqFAK0ICotHH5jN_aezdP1zey8WRZRU,7468
+pythagoras-0.24.10.dist-info/RECORD,,

pythagoras/_010_basic_portals/exceptions.py

@@ -1,36 +0,0 @@
-class PythagorasException(Exception):
-    """Base exception class for all Pythagoras-related errors.
-
-    This is the base class for all custom exceptions raised by the Pythagoras
-    library. It provides a common interface and functionality for all
-    Pythagoras-specific error conditions.
-
-    Attributes:
-        message: A human-readable description of the error.
-    """
-
-    def __init__(self, message):
-        """Initialize the exception with an error message.
-
-        Args:
-            message: A string describing the error that occurred.
-        """
-        self.message = message
-
-
-class NonCompliantFunction(PythagorasException):
-    """Exception raised when a function does not comply with Pythagoras requirements.
-
-    This exception is raised when a function fails to meet the compliance
-    requirements for use within the Pythagoras framework. This typically
-    occurs when functions cannot be properly serialized, analyzed, or
-    executed within the portal environment.
-    """
-
-    def __init__(self, message):
-        """Initialize the exception with an error message.
-
-        Args:
-            message: A string describing why the function is non-compliant.
-        """
-        PythagorasException.__init__(self, message)