pythagoras 0.24.7__tar.gz → 0.24.10__tar.gz

{pythagoras-0.24.7 → pythagoras-0.24.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pythagoras
-Version: 0.24.7
+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.7 → pythagoras-0.24.10}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "pythagoras"
-version = "0.24.7"
+version = "0.24.10"
 authors = [
     {name = "Volodymyr (Vlad) Pavlov", email = "vlpavlov@ieee.org"},
 ]

{pythagoras-0.24.7 → pythagoras-0.24.10}/src/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-0.24.7 → pythagoras-0.24.10}/src/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-0.24.7 → pythagoras-0.24.10}/src/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-0.24.7 → pythagoras-0.24.10}/src/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-0.24.7 → pythagoras-0.24.10}/src/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-0.24.10/src/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-0.24.7 → pythagoras-0.24.10}/src/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-0.24.7 → pythagoras-0.24.10}/src/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-0.24.7 → pythagoras-0.24.10}/src/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-0.24.7 → pythagoras-0.24.10}/src/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-0.24.7 → pythagoras-0.24.10}/src/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-0.24.7 → pythagoras-0.24.10}/src/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-0.24.7 → pythagoras-0.24.10}/src/pythagoras/_040_logging_code_portals/logging_portal_core_classes.py

@@ -39,6 +39,9 @@ class LoggingFn(StorableFn):
     exceptions, and custom events. It also supports an excessive_logging mode
     that enables storing rich per-call artifacts.
 
+    A logging function can only be called with keyword arguments.
+    It can't be called with positional arguments.
+
     Attributes:
         _auxiliary_config_params_at_init (dict): Internal configuration store
             inherited from StorableFn. Includes the 'excessive_logging' flag
@@ -156,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:
@@ -726,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__()
@@ -794,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.
@@ -918,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-0.24.7 → pythagoras-0.24.10}/src/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-0.24.7 → pythagoras-0.24.10}/src/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-0.24.7 → pythagoras-0.24.10}/src/pythagoras/_060_autonomous_code_portals/autonomous_decorators.py

@@ -23,6 +23,9 @@ Autonomous functions can have nested functions and classes.
 Only ordinary functions can be autonomous. Asynchronous functions, closures,
 class methods, and lambda functions cannot be autonomous.
 
+An autonomous function can only be called with keyword arguments.
+It can't be called with positional arguments.
+
 Autonomous functions support partial application of arguments:
 the process of pre-filling some arguments of a function,
 producing a new autonomous function that takes the remaining arguments.
@@ -71,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)