pythagoras 0.22.2__py3-none-any.whl → 0.23.1__py3-none-any.whl

pythagoras/_010_basic_portals/basic_portal_core_classes.py

@@ -123,7 +123,7 @@ def get_active_portal() -> BasicPortal:
         return _active_portals_stack[-1]
 
     if _most_recently_created_portal is None:
-        sys.modules["pythagoras"].instantiate_default_local_portal()
+        sys.modules["pythagoras"]._instantiate_default_local_portal()
 
     _active_portals_stack.append(_most_recently_created_portal)
     _active_portals_counters_stack.append(1)

pythagoras/_020_ordinary_code_portals/ordinary_portal_core_classes.py

@@ -15,7 +15,7 @@ from .._010_basic_portals.basic_portal_core_classes import (
 
 
 def get_normalized_function_source(a_func: OrdinaryFn | Callable | str) -> str:
-    """Return function's source code in a 'canonical' form.
+    """Return a function's source code in a 'canonical' form.
 
     Remove all comments, docstrings and empty lines;
     standardize code formatting based on PEP 8.
@@ -263,7 +263,7 @@ class OrdinaryFn(PortalAwareClass):
 
     def __setstate__(self, state):
         """This method is called when the object is unpickled."""
-        PortalAwareClass.__setstate__(self, state)
+        super().__setstate__(state)
         self._source_code = state["source_code"]
 
 

pythagoras/_030_data_portals/__init__.py

@@ -22,10 +22,10 @@ This is done to address limitations of some file systems
 and to optimize work sith cloud storage (e.g. S3).
 
 Typically, a DataPortal is implemented as
-a shared directory on a file system (e.g. Amazon EFS),
-or as a shared bucket in a cloud storage (e.g. Amazon S3).
-In this case, a ValueAddr becomes a part of file path
-or a URL (e.g. a hash serves as a filename,
+a shared directory on a file system (e.g., Amazon EFS),
+or as a shared bucket in a cloud storage (e.g., Amazon S3).
+In this case, a ValueAddr becomes a part of a file path
+or a URL (e.g., a hash serves as a filename,
 and a prefix is a folder name).
 """
 

pythagoras/_030_data_portals/data_portal_core_classes.py

@@ -419,7 +419,7 @@ class ValueAddr(HashAddr):
     ValueAddr is a universal global identifier of any (constant) value.
 
     Using only the value's hash should (theoretically) be enough to
-    uniquely address all possible data objects that the humanity will create
+    uniquely address all possible data objects that humanity will create
     in the foreseeable future (see, for example, ipfs.io).
 
     However, an address also includes a descriptor with an optional suffix.
@@ -437,8 +437,8 @@ class ValueAddr(HashAddr):
             descriptor = data_value_addr.descriptor
             hash_signature = data_value_addr.hash_signature
             HashAddr.__init__(self
-                              , descriptor=descriptor
-                              , hash_signature=hash_signature)
+                , descriptor=descriptor
+                , hash_signature=hash_signature)
             return
 
         assert not isinstance(data, HashAddr), (
@@ -448,8 +448,8 @@ class ValueAddr(HashAddr):
         descriptor = self._build_descriptor(data)
         hash_signature = self._build_hash_signature(data)
         HashAddr.__init__(self
-                          , descriptor=descriptor
-                          , hash_signature=hash_signature)
+            , descriptor=descriptor
+            , hash_signature=hash_signature)
 
         self._value_cache = data
 
@@ -584,7 +584,10 @@ class ValueAddr(HashAddr):
                      ) -> HashAddr:
         """(Re)construct address from text representations of descriptor and hash"""
 
-        address = super().from_strings(descriptor=descriptor, hash_signature=hash_signature, assert_readiness=False)
+        address = super().from_strings(
+            descriptor=descriptor
+            , hash_signature=hash_signature
+            , assert_readiness=False)
         address._containing_portals = set()
         if assert_readiness:
             if not address.ready:

pythagoras/_040_logging_code_portals/__init__.py

@@ -1,24 +1,18 @@
 """Classes and functions to work with application-level logging.
 
-The main class in this sub-package is LoggingCodePortal, which extends BasicPortal
+The main class in this sub-package is LoggingCodePortal, which extends DataPortal
 to provide application-level logging capabilities for events and exceptions.
 'Application-level' means that the events and exceptions are logged into
-location(s) that is(are) the same across the entire application,
-and does(do) not depend on the specific function from which
-the even or exception is originated.
+location(s) that is(are) the same across the entire application.
 
-BasicPortal provides two attributes, `_crash_history` and `event_log`,
-which are persistent dictionaries (PersiDict-s) that store
-the exceptions history and event log respectively.
+LoggingCodePortal provides three attributes, _run_history, _crash_history,
+and  _event_history`, which are persistent dictionaries (PersiDict-s) that store
+the exceptions and logged / recorded events.
 
-Static methods `log_exception` and `log_event` are provided to log
+Functions log_exception() and `log_event() are provided to log
 exceptions and events. These methods are designed to be
 called from anywhere in the application, and they will log the exception
-or event into all the active LoggingPortals. 'Active' LoggingPortals are
-those that have been registered with the current
-stack of nested 'with' statements.
-
-The class also supports logging uncaught exceptions globally.
+or event into the best suitable LoggingPortal.
 """
 
 from .logging_portal_core_classes import *

pythagoras/_040_logging_code_portals/exception_processing_tracking.py

@@ -1,22 +1,24 @@
 def _exception_needs_to_be_processed(exc_type, exc_value, trace_back) -> bool:
+    """Chack if the exception needs to be logged by Pythagoras"""
     if exc_type is None:
         return False
 
     if hasattr(exc_value, "__notes__"):
-        if "__suppress_logging__" in exc_value.__notes__:
+        if "__suppress_pythagoras_logging__" in exc_value.__notes__:
             return False
         else:
             return True
 
-    if hasattr(exc_value, "__suppress_logging__"):
+    if hasattr(exc_value, "__suppress_pythagoras_logging__"):
         return False
 
     return True
 
 
 def _mark_exception_as_processed(exc_type, exc_value, trace_back) -> None:
+    """Mark the exception as processed by Pythagoras"""
     if hasattr(exc_value, "add_note"):
         exc_value.add_note(
-            "__suppress_logging__")
+            "__suppress_pythagoras_logging__")
     else:
-        exc_value.__suppress_logging__ = True
+        exc_value.__suppress_pythagoras_logging__ = True

pythagoras/_040_logging_code_portals/kw_args.py

@@ -7,7 +7,7 @@ from parameterizable import sort_dict_by_keys
 class KwArgs(dict):
     """ A class that encapsulates keyword arguments for a function call.
 
-    It allows to "normalize" the dictionary by sorting the keys
+    It allows "normalizing" the dictionary by sorting the keys
     and replacing values with their hash addresses
     in order to always get the same hash values
     for the same lists of arguments.

pythagoras/_040_logging_code_portals/logging_portal_core_classes.py

@@ -75,7 +75,6 @@ class LoggingFn(StorableFn):
         return StorableFn.portal.__get__(self)
 
 
-
 class LoggingFnCallSignature:
     """A signature of a call to a (logging) function.
 
@@ -389,7 +388,6 @@ class LoggingFnExecutionRecord(NotPicklable):
                 f"{self.call_signature.fn_name} execution results.")
 
 
-
 class LoggingFnExecutionFrame(NotPicklable):
     call_stack: list[LoggingFnExecutionFrame] = []
 
@@ -512,7 +510,7 @@ class LoggingCodePortal(DataPortal):
     from which the event or exception is raised.
 
     The class provides two dictionaries, `_crash_history` and `event_log`,
-    to store the exceptions history and event log respectively.
+    to store the exception history and event log respectively.
 
     Static methods `log_exception` and `log_event` are provided to log
     exceptions and events. These methods are designed to be

pythagoras/_050_safe_code_portals/__init__.py

@@ -1,2 +1,15 @@
+"""Classes and functions that allow safe execution of code.
+
+The main classes in this sub-package are SafeCodePortal and SafeFn,
+which extend LoggingCodePortal and LoggingFn
+to provide safe execution capabilities for logging functions.
+
+SafeFn functions can't access (hence can't harm) any data/devices outside
+the function's local scope and the portal.
+
+This functionality has not been implemented yet.
+It will be done soon by integrating https://pypi.org/project/RestrictedPython/
+"""
+
 from .safe_portal_core_classes import *
 from .safe_decorator import *

pythagoras/_050_safe_code_portals/safe_decorator.py

@@ -7,7 +7,7 @@ from .safe_portal_core_classes import SafeFn, SafeCodePortal
 
 
 class safe(logging):
-    """A decorator that converts a Python function into an SafeFn object.
+    """A decorator that converts a Python function into a SafeFn object.
     """
 
     def __init__(self

pythagoras/_050_safe_code_portals/safe_portal_core_classes.py

@@ -1,3 +1,16 @@
+"""Classes and functions that allow safe execution of code.
+
+The main classes in this sub-package are SafeCodePortal and SafeFn,
+which extend LoggingCodePortal and LoggingFn
+to provide safe execution capabilities for logging functions.
+
+SafeFn functions can't access (hence can't harm) any data/devices outside
+the function's local scope and the portal.
+
+This functionality has not been implemented yet.
+It will be done soon by integrating https://pypi.org/project/RestrictedPython/
+"""
+
 from __future__ import annotations
 
 from typing import Callable
@@ -49,11 +62,4 @@ class SafeFn(LoggingFn):
         return LoggingFn.portal.__get__(self)
 
 
-    # @portal.setter
-    # def portal(self, new_portal: SafeCodePortal) -> None:
-    #     if not isinstance(new_portal, SafeCodePortal):
-    #         raise TypeError("portal must be a LoggingCodePortal instance")
-    #     LoggingFn.portal.__set__(self, new_portal)
-
-
 register_parameterizable_class(SafeCodePortal)

pythagoras/_060_autonomous_code_portals/__init__.py

@@ -1,46 +1,35 @@
 """Classes and utilities to work with autonomous functions.
 
-In an essence, an 'autonomous' function contains self-sufficient code
+In essence, an 'autonomous' function contains self-sufficient code
 that does not depend on external imports or definitions. All required
-imports should be done inside the function body. Only ordinary functions
-can be autonomous.
+imports should be done inside the function body.
+Only ordinary functions can be autonomous.
 
 Autonomous functions are always allowed to use the built-in objects
 (functions, types, variables), as well as global objects,
 explicitly imported inside the function body. An autonomous function
-is allowed to use other autonomous functions,
-created outside the autonomous function,
-if they belong to the same island.
-
-An island is namespace that groups autonomous functions together.
-An autonomous function can use other autonomous functions from the same island
-without explicitly importing them.
+is allowed to use other autonomous functions if they are passed as
+input arguments to the function.
 
 Autonomous functions are not allowed to:
 
     * use global objects, imported or defined outside the function body
-      (except built-in objects and other autonomous functions
-      from the same island);
+      (except built-in objects);
     * use yield (yield from) statements;
     * use nonlocal variables, referencing the outside objects.
 
-If an autonomous function is using other autonomous functions
-from the same island, it is called "loosely autonomous function".
-Otherwise, it is called "strictly autonomous function".
-
 Autonomous functions can have nested functions and classes.
 
-Only regular functions can be autonomous. Asynchronous functions,
-class methods and lambda functions cannot be autonomous.
+Only ordinary functions can be autonomous. Asynchronous functions, closures,
+class methods, and lambda functions cannot be autonomous.
 
-This module defines  decorators which are used to
-inform Pythagoras that a function is intended to be autonomous,
-and to enforce autonomicity requirements:
-@autonomous() and @strictly_autonomous() .
+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.
 
-It also defines functions which are used to check whether a corresponding
-decorator was added earlier to another function: is_autonomous(),
-is_loosely_autonomous(), and is_strictly_autonomous().
+This module defines a decorator which is used to
+inform Pythagoras that a function is intended to be autonomous
+and to enforce autonomicity requirements.
 
 Applying a decorator to a function ensures both static and runtime autonomicity
 checks are performed for the function. Static checks happen at the time

pythagoras/_060_autonomous_code_portals/autonomous_decorators.py

@@ -1,33 +1,39 @@
 """Support for work with autonomous functions.
 
-In essence, an autonomous function contains self-sufficient code
-that does not depend on external imports or definitions.
+In essence, an 'autonomous' function contains self-sufficient code
+that does not depend on external imports or definitions. All required
+imports should be done inside the function body.
+Only ordinary functions can be autonomous.
 
 Autonomous functions are always allowed to use the built-in objects
 (functions, types, variables), as well as global objects,
 explicitly imported inside the function body. An autonomous function
-may be allowed to use other autonomous functions, which are created or imported
-outside the autonomous function, provided that they belong to the same island.
+is allowed to use other autonomous functions if they are passed as
+input arguments to the function.
 
 Autonomous functions are not allowed to:
+
     * use global objects, imported or defined outside the function body
-      (except built-in objects and, possibly,
-      other autonomous functions from the same island);
+      (except built-in objects);
     * use yield (yield from) statements;
     * use nonlocal variables, referencing the outside objects.
 
-If an autonomous function is allowed to use other autonomous functions,
-it is called "loosely autonomous function". Otherwise, it is called
-"strictly autonomous function".
-
 Autonomous functions can have nested functions and classes.
 
-Only ordinary functions can be autonomous. Asynchronous functions,
-class methods and lambda functions cannot be autonomous.
+Only ordinary functions can be autonomous. Asynchronous functions, closures,
+class methods, and lambda functions cannot be autonomous.
+
+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.
 
-Decorators @autonomous, @loosely_autonomous, and @strictly_autonomous
-allow to inform Pythagoras that a function is intended to be autonomous,
-and to enforce autonomicity requirements for the function.
+This module defines a decorator which is used to
+inform Pythagoras that a function is intended to be autonomous
+and to enforce autonomicity requirements.
+
+Applying a decorator to a function ensures both static and runtime autonomicity
+checks are performed for the function. Static checks happen at the time
+of decoration, while runtime checks happen at the time of function execution.
 """
 from typing import Callable
 
@@ -59,31 +65,6 @@ class autonomous(safe):
 
 
     def __call__(self, fn: Callable|str) -> AutonomousFn:
-        """Decorator for autonomous functions.
-
-        It does both static and dynamic checks for autonomous functions.
-
-        Static checks: it checks whether the function uses any global
-        non-built-in objects which do not have associated import statements
-        inside the function. If allow_idempotent==True,
-        global idempotent functions are also allowed.
-        The decorator also checks whether the function is using
-        any non-local objects variables, and whether the function
-        has yield / yield from statements in its code. If static checks fail,
-        the decorator throws a FunctionAutonomicityError exception.
-
-        Dynamic checks: during the execution time it hides all the global
-        and non-local objects from the function, except the built-in ones
-        (and idempotent ones, if allow_idempotent==True).
-        If a function tries to use a non-built-in
-        (and non-idempotent, if allow_idempotent==True)
-        object without explicitly importing it inside the function body,
-        it will result in raising an exception.
-
-        Currently, neither static nor dynamic checks are guaranteed to catch
-        all possible violations of function autonomy requirements.
-        """
-
         wrapper = AutonomousFn(fn
             ,portal=self._portal
             ,fixed_kwargs=self._fixed_kwargs

pythagoras/_060_autonomous_code_portals/autonomous_portal_core_classes.py

@@ -5,7 +5,7 @@ from typing import Callable, Any
 
 from persidict import PersiDict, Joker, KEEP_CURRENT
 from .._020_ordinary_code_portals.code_normalizer import _pythagoras_decorator_names
-from .. import DataPortal
+from .._030_data_portals import DataPortal
 from .._040_logging_code_portals import KwArgs
 
 from .._060_autonomous_code_portals.names_usage_analyzer import (
@@ -14,9 +14,6 @@ from .._060_autonomous_code_portals.names_usage_analyzer import (
 from .._050_safe_code_portals.safe_portal_core_classes import (
     SafeFn, SafeCodePortal)
 
-import pythagoras as pth
-
-
 class AutonomousCodePortal(SafeCodePortal):
     
     def __init__(self
@@ -36,7 +33,7 @@ class AutonomousFn(SafeFn):
     _fixed_kwargs_packed: KwArgs | None
 
     def __init__(self, fn: Callable|str|SafeFn
-                 , fixed_kwargs: dict|None = None
+                 , fixed_kwargs: dict[str,Any]|None = None
                  , excessive_logging: bool|Joker = KEEP_CURRENT
                  , portal: AutonomousCodePortal|None = None):
         super().__init__(fn=fn
@@ -106,6 +103,14 @@ class AutonomousFn(SafeFn):
 
 
     def fix_kwargs(self, **kwargs) -> AutonomousFn:
+        """Create a new function by pre-filling some arguments.
+
+        This is called a partial application in functional programming
+        It allows creating specialized functions from general ones by
+        transforming a function with multiple parameters
+        into another function with fewer parameters by fixing some arguments.
+        """
+
         overlapping_keys = set(kwargs.keys()) & set(self.fixed_kwargs.keys())
         assert len(overlapping_keys) == 0
         new_fixed_kwargs = {**self.fixed_kwargs,**kwargs}
@@ -147,5 +152,6 @@ class AutonomousFn(SafeFn):
         """
         super()._invalidate_cache()
         if hasattr(self, "_fixed_kwargs_cached"):
-            assert hasattr(self, "_fixed_kwargs_packed"), "Premature cache invalidation: fixed_kwargs_packed is missing."
+            assert (hasattr(self, "_fixed_kwargs_packed")
+                , "Premature cache invalidation: fixed_kwargs_packed is missing.")
             del self._fixed_kwargs_cached

pythagoras/_060_autonomous_code_portals/names_usage_analyzer.py

@@ -14,7 +14,7 @@ class NamesUsedInFunction:
         self.accessible = set() # all names, currently accessable within the function
 
 class NamesUsageAnalyzer(ast.NodeVisitor):
-    """Collect data needed to analyze function autonomy.
+    """Collect data needed to analyze function autonomicity.
 
     This class is a visitor of an AST (Abstract Syntax Tree) that collects data
     needed to analyze function autonomy.

pythagoras/_070_protected_code_portals/__init__.py

@@ -1,4 +1,20 @@
-from .OK_const import *
+"""Classes and functions that allow protected execution of code.
+
+Protected functions are functions that can be executed only if
+certain conditions are met before the execution; also, certain conditions
+must be met after the execution in order for the system to accept
+and use execution results. These conditions are called validators
+(pre-validators and post-validators). A protected function can have many
+pre-validators and post-validators.
+
+Validators can be passive (e.g., check if the node has enough RAM)
+or active (e.g., check if some external library is installed, and,
+if not, try to install it). Validators can be rather complex
+(e.g., check if the result, returned by the function, is a valid image).
+Under the hood, validators are autonomous functions.
+"""
+
+from .validation_succesful_const import *
 from .protected_portal_core_classes import *
 from .protected_decorators import *
 from .system_utils import *

pythagoras/_070_protected_code_portals/basic_pre_validators.py

@@ -1,11 +1,11 @@
 from .._070_protected_code_portals import SimplePreValidatorFn
-from .OK_const import OKClass
+from .validation_succesful_const import ValidationSuccessClass
 
 
-def _at_least_X_CPU_cores_free_check(n:int)-> OKClass | None:
+def _at_least_X_CPU_cores_free_check(n:int)-> ValidationSuccessClass | None:
     cores = pth.get_unused_cpu_cores()
     if cores >= n-0.1:
-        return pth.OK
+        return pth.VALIDATION_SUCCESSFUL
 
 
 def unused_cpu(cores:int) -> SimplePreValidatorFn:
@@ -14,10 +14,10 @@ def unused_cpu(cores:int) -> SimplePreValidatorFn:
     return SimplePreValidatorFn(_at_least_X_CPU_cores_free_check).fix_kwargs(n=cores)
 
 
-def _at_least_X_G_RAM_free_check(x:int)-> OKClass | None:
+def _at_least_X_G_RAM_free_check(x:int)-> ValidationSuccessClass | None:
     ram = pth.get_unused_ram_mb() / 1024
     if ram >= x-0.1:
-        return pth.OK
+        return pth.VALIDATION_SUCCESSFUL
 
 
 def unused_ram(Gb:int) -> SimplePreValidatorFn:
@@ -26,15 +26,15 @@ def unused_ram(Gb:int) -> SimplePreValidatorFn:
     return SimplePreValidatorFn(_at_least_X_G_RAM_free_check).fix_kwargs(x=Gb)
 
 
-def _check_python_package_and_install_if_needed(package_name)-> OKClass | None:
+def _check_python_package_and_install_if_needed(package_name)-> ValidationSuccessClass | None:
     assert isinstance(package_name, str)
     import importlib
     try:
         importlib.import_module(package_name)
-        return pth.OK
+        return pth.VALIDATION_SUCCESSFUL
     except:
         pth.install_package(package_name)
-        return pth.OK
+        return pth.VALIDATION_SUCCESSFUL
 
 
 def installed_packages(*args)  -> list[SimplePreValidatorFn]:

pythagoras/_070_protected_code_portals/package_manager.py

@@ -9,7 +9,6 @@ def _install_uv_and_pip() -> None:
     global _uv_and_pip_installation_needed
     if not _uv_and_pip_installation_needed:
         return
-    _uv_pip_installation_attempted = False
 
     try:
         importlib.import_module("uv")

pythagoras/_070_protected_code_portals/protected_decorators.py

@@ -1,6 +1,6 @@
 """Support for work with protected functions."""
 
-from typing import Callable
+from typing import Callable, Any
 
 from .validator_fn_classes import ValidatorFn
 from .._060_autonomous_code_portals import autonomous
@@ -15,7 +15,7 @@ class protected(autonomous):
     def __init__(self
                  , pre_validators: list[ValidatorFn] | None = None
                  , post_validators: list[ValidatorFn] | None = None
-                 , fixed_kwargs: dict | None = None
+                 , fixed_kwargs: dict[str,Any] | None = None
                  , excessive_logging: bool|Joker = KEEP_CURRENT
                  , portal: ProtectedCodePortal | None = None
                  ):

pythagoras/_070_protected_code_portals/protected_portal_core_classes.py

@@ -1,23 +1,37 @@
+"""Classes and functions that allow protected execution of code.
+
+Protected functions are functions that can be executed only if
+certain conditions are met before the execution; also, certain conditions
+must be met after the execution in order for the system to accept
+and use execution results. These conditions are called validators
+(pre-validators and post-validators). A protected function can have many
+pre-validators and post-validators.
+
+Validators can be passive (e.g., check if the node has enough RAM)
+or active (e.g., check if some external library is installed, and,
+if not, try to install it). Validators can be rather complex
+(e.g., check if the result, returned by the function, is a valid image).
+Under the hood, validators are autonomous functions.
+"""
+
 from __future__ import annotations
 
 from copy import copy
-from typing import Callable, Any, List
+from typing import Callable, Any
 
 from persidict import PersiDict, Joker, KEEP_CURRENT
 
-from .validator_fn_classes import ValidatorFn, PreValidatorFn, PostValidatorFn, SimplePreValidatorFn, \
-    ComplexPreValidatorFn
+from .validator_fn_classes import *
 from .._030_data_portals import DataPortal
 from .._040_logging_code_portals import KwArgs
 from .._030_data_portals import ValueAddr
 from parameterizable import sort_dict_by_keys
 from .list_flattener import flatten_list
-from .OK_const import OK
+from .validation_succesful_const import VALIDATION_SUCCESSFUL
 
 
 from .._060_autonomous_code_portals import (
     AutonomousCodePortal, AutonomousFn)
-from .fn_arg_names_checker import check_if_fn_accepts_args
 
 
 class ProtectedCodePortal(AutonomousCodePortal):
@@ -34,8 +48,8 @@ class ProtectedCodePortal(AutonomousCodePortal):
 
 class ProtectedFn(AutonomousFn):
 
-    _pre_validators_cached: list[AutonomousFn] | None
-    _post_validators_cached: list[AutonomousFn] | None
+    _pre_validators_cached: list[ValidatorFn] | None
+    _post_validators_cached: list[ValidatorFn] | None
     _pre_validators_addrs: list[ValueAddr]
     _post_validators_addrs: list[ValueAddr]
 
@@ -43,27 +57,39 @@ class ProtectedFn(AutonomousFn):
     pre_validators_arg_names = ["packed_kwargs", "fn_addr"]
 
     def __init__(self, fn: Callable | str
-                 , pre_validators: list[AutonomousFn] | List[Callable] | None = None
-                 , post_validators: list[AutonomousFn] | List[Callable] | None = None
-                 , excessive_logging: bool|None = KEEP_CURRENT
-                 , fixed_kwargs: dict | None = None
+                 , pre_validators: list[ValidatorFn] | list[Callable] | None = None
+                 , post_validators: list[ValidatorFn] | list[Callable] | None = None
+                 , excessive_logging: bool | Joker = KEEP_CURRENT
+                 , fixed_kwargs: dict[str,Any] | None = None
                  , portal: ProtectedCodePortal | None = None):
         super().__init__(fn=fn
             , portal = portal
             , fixed_kwargs=fixed_kwargs
             , excessive_logging = excessive_logging)
 
-        pre_validators = self._normalize_validators(pre_validators, PreValidatorFn)
-        post_validators = self._normalize_validators(post_validators, PostValidatorFn)
+        if pre_validators is None:
+            pre_validators = list()
+        else:
+            pre_validators = copy(pre_validators)
+
+        if post_validators is None:
+            post_validators = list()
+        else:
+            post_validators = copy(post_validators)
 
         if isinstance(fn, ProtectedFn):
             pre_validators += fn.pre_validators
             post_validators += fn.post_validators
 
-        self._pre_validators_cached = self._normalize_validators(pre_validators, PreValidatorFn)
-        self._post_validators_cached = self._normalize_validators(post_validators, PostValidatorFn)
-        self._pre_validators_addrs = [ValueAddr(g, store=False) for g in self._pre_validators_cached]
-        self._post_validators_addrs = [ValueAddr(v, store=False) for v in self._post_validators_cached]
+        pre_validators = self._normalize_validators(pre_validators, PreValidatorFn)
+        post_validators = self._normalize_validators(post_validators, PostValidatorFn)
+
+        self._pre_validators_cached = pre_validators
+        self._post_validators_cached = post_validators
+        self._pre_validators_addrs = [ValueAddr(g, store=False)
+                                      for g in self._pre_validators_cached]
+        self._post_validators_addrs = [ValueAddr(v, store=False)
+                                       for v in self._post_validators_cached]
 
 
     def __getstate__(self):
@@ -120,7 +146,7 @@ class ProtectedFn(AutonomousFn):
                     pre_validation_result = pre_validator()
                 else:
                     pre_validation_result = pre_validator(packed_kwargs=kw_args, fn_addr = self.addr)
-                if pre_validation_result is not OK:
+                if pre_validation_result is not VALIDATION_SUCCESSFUL:
                     return False
             return True
 
@@ -132,7 +158,7 @@ class ProtectedFn(AutonomousFn):
             portal.entropy_infuser.shuffle(post_validators)
             for post_validator in post_validators:
                 if post_validator(packed_kwargs=kw_args, fn_addr = self.addr
-                        , result=result) is not OK:
+                        , result=result) is not VALIDATION_SUCCESSFUL:
                     return False
             return True
 

pythagoras/_070_protected_code_portals/{OK_const.py → validation_succesful_const.py}

@@ -1,4 +1,6 @@
-class OKClass:
+class ValidationSuccessClass:
+    """Singleton class to represent a successful validation."""
+
     _instance = None
 
     def __new__(cls):
@@ -6,4 +8,4 @@ class OKClass:
             cls._instance = super().__new__(cls)
         return cls._instance
 
-OK = OKClass()
+VALIDATION_SUCCESSFUL = ValidationSuccessClass()

pythagoras/_080_pure_code_portals/__init__.py

@@ -1,10 +1,10 @@
 """Decorators and utilities to work with pure functions.
 
-A pure function is an autonomous function that has no side effects and
+A pure function is a protected function that has no side effects and
 always returns the same result if it is called multiple times
 with the same arguments.
 
-This module defines a decorator which is used to inform Pythagoras that
+This subpackage defines a decorator which is used to inform Pythagoras that
 a function is intended to be pure: @pure().
 
 Pythagoras persistently caches results, produced by a pure function, so that
@@ -16,22 +16,8 @@ While caching the results of a pure function, Pythagoras also tracks
 changes in the source code of the function. If the source code of a pure
 function changes, the function is executed again on the next call.
 However, the previously cached results are still available
-for the old version of the function.
-
-A pure function must be autonomous. Pythagoras tracks source code changes
-for the pure function as well other autonomous functions it is using,
-provided they belong to the same island. Pythagoras does not track source code
-changes for functions from other islands, even if they are used
-by the pure function. Pythagoras also does not track any other
-source code changes (e.g. changes in the imported packages).
-
-Pythagoras provides infrastructure for remote execution of
-pure functions in distributed environments. Pythagoras employs
-an asynchronous execution model called 'swarming':
-you do not know when your function will be executed,
-what machine will execute it, and how many times it will be executed.
-Pythagoras ensures that the function will be eventually executed
-at least once, but does not offer any further guarantees.
+for the old version of the function. Only changes in the function's
+source code are tracked.
 """
 
 from .pure_core_classes import (

pythagoras/_080_pure_code_portals/pure_core_classes.py

@@ -1,3 +1,25 @@
+"""Classes to work with pure functions.
+
+A pure function is a protected function that has no side effects and
+always returns the same result if it is called multiple times
+with the same arguments.
+
+This subpackage defines a decorator which is used to inform Pythagoras that
+a function is intended to be pure: @pure().
+
+Pythagoras persistently caches results, produced by a pure function, so that
+if the function is called multiple times with the same arguments,
+the function is executed only once, and the cached result is returned
+for all the subsequent executions.
+
+While caching the results of a pure function, Pythagoras also tracks
+changes in the source code of the function. If the source code of a pure
+function changes, the function is executed again on the next call.
+However, the previously cached results are still available
+for the old version of the function. Only changes in the function's
+source code are tracked.
+"""
+
 from __future__ import annotations
 
 import time
@@ -9,22 +31,19 @@ import pandas as pd
 
 from persidict import PersiDict, Joker, KEEP_CURRENT
 
-from .._010_basic_portals import get_all_known_portals, get_nonactive_portals, get_active_portal
-from .._070_protected_code_portals import ProtectedCodePortal, ProtectedFn
+from persidict import WriteOnceDict
+
+from .._010_basic_portals import *
 from .._010_basic_portals.basic_portal_core_classes import (
     _describe_persistent_characteristic)
-from persidict import WriteOnceDict
-from .._040_logging_code_portals.logging_portal_core_classes import (
-    LoggingFnCallSignature)
 
 from .._030_data_portals import HashAddr, ValueAddr
-
-from .._060_autonomous_code_portals.autonomous_portal_core_classes import (
-    AutonomousFn)
+from .._040_logging_code_portals import *
 
 
-from .._040_logging_code_portals.kw_args import KwArgs
+from .._070_protected_code_portals import *
 
+# from .._040_logging_code_portals.kw_args import KwArgs
 
 ASupportingFunc:TypeAlias = str | AutonomousFn
 
@@ -232,23 +251,16 @@ class PureFn(ProtectedFn):
         return ProtectedFn.portal.__get__(self)
 
 
-    # @portal.setter
-    # def portal(self, new_portal: PureCodePortal) -> None: #*#*#
-    #     if not isinstance(new_portal, PureCodePortal):
-    #         raise TypeError("portal must be a PureCodePortal instance")
-    #     ProtectedFn.portal.__set__(self, new_portal)
-
-
 class PureFnExecutionResultAddr(HashAddr):
-    """An address of the result of an execution of a pure function.
+    """An address of a (future) result of pure function execution.
 
     This class is used to point to the result of an execution of a pure
-    function in a portal. The address is used to request an execution and
+    function in a portal. The address is used to request an execution or
     to retrieve the result (if available) from the portal.
 
     The address also provides access to various logs and records of the
     function execution, such as environmental contexts of the execution attempts,
-    outputs printed, exceptions thrown and events emitted.
+    outputs printed, exceptions thrown, and events emitted.
     """
     _fn_cache: PureFn | None
     _call_signature_cache: LoggingFnCallSignature | None

pythagoras/_080_pure_code_portals/pure_decorator.py

@@ -1,7 +1,28 @@
-from typing import Callable
+"""Decorator to work with pure functions.
 
-from .._070_protected_code_portals import protected
-from .._060_autonomous_code_portals import AutonomousFn
+A pure function is a protected function that has no side effects and
+always returns the same result if it is called multiple times
+with the same arguments.
+
+This subpackage defines a decorator which is used to inform Pythagoras that
+a function is intended to be pure: @pure().
+
+Pythagoras persistently caches results, produced by a pure function, so that
+if the function is called multiple times with the same arguments,
+the function is executed only once, and the cached result is returned
+for all the subsequent executions.
+
+While caching the results of a pure function, Pythagoras also tracks
+changes in the source code of the function. If the source code of a pure
+function changes, the function is executed again on the next call.
+However, the previously cached results are still available
+for the old version of the function. Only changes in the function's
+source code are tracked.
+"""
+
+from typing import Callable, Any
+
+from .._070_protected_code_portals import protected, ValidatorFn
 from .._080_pure_code_portals.pure_core_classes import (
     PureCodePortal, PureFn)
 
@@ -10,9 +31,9 @@ from persidict import KEEP_CURRENT, Joker
 class pure(protected):
 
     def __init__(self
-                 , pre_validators: list[AutonomousFn] | None = None
-                 , post_validators: list[AutonomousFn] | None = None
-                 , fixed_kwargs: dict | None = None
+                 , pre_validators: list[ValidatorFn] | None = None
+                 , post_validators: list[ValidatorFn] | None = None
+                 , fixed_kwargs: dict[str, Any] | None = None
                  , excessive_logging: bool | Joker = KEEP_CURRENT
                  , portal: PureCodePortal | None = None
                  ):

pythagoras/_090_swarming_portals/__init__.py

@@ -1 +1,12 @@
+""" Classes and functions that enable swarming algorithm.
+
+Pythagoras provides infrastructure for remote execution of
+pure functions in distributed environments. Pythagoras employs
+an asynchronous execution model called 'swarming':
+you do not know when your function will be executed,
+what machine will execute it, and how many times it will be executed.
+Pythagoras ensures that the function will be eventually executed
+at least once but does not offer any further guarantees.
+"""
+
 from .swarming_portals import *

pythagoras/_090_swarming_portals/swarming_portals.py

@@ -1,3 +1,14 @@
+""" Classes and functions that enable swarming algorithm.
+
+Pythagoras provides infrastructure for remote execution of
+pure functions in distributed environments. Pythagoras employs
+an asynchronous execution model called 'swarming':
+you do not know when your function will be executed,
+what machine will execute it, and how many times it will be executed.
+Pythagoras ensures that the function will be eventually executed
+at least once but does not offer any further guarantees.
+"""
+
 from __future__ import annotations
 
 import atexit

pythagoras/_100_top_level_API/default_local_portal.py

@@ -1,6 +1,8 @@
-from .._090_swarming_portals import SwarmingPortal
+from .._010_basic_portals import get_active_portal
 from .._010_basic_portals import get_default_portal_base_dir
+from .._090_swarming_portals import SwarmingPortal
 
 
-def instantiate_default_local_portal():
+def _instantiate_default_local_portal():
+    #NB: there is a hidden circular dependency from get_active_portal()
     SwarmingPortal(root_dict = get_default_portal_base_dir())

pythagoras/_900_project_stats_collector/__init__.py

@@ -0,0 +1 @@
+"""This subpackage is only needed for development. No runtime usage."""

pythagoras/_900_project_stats_collector/project_analyzer.py

@@ -1,3 +1,4 @@
+"""This module is only needed for development. No runtime usage."""
 import ast
 import pandas as pd
 from pathlib import Path

pythagoras/__init__.py

@@ -1,9 +1,21 @@
-"""Pythagoras aims to democratize access to distributed serverless compute.
+"""Distributed serverless compute at a global scale.
 
-We make it simple and inexpensive to create, deploy and run
-massively parallel algorithms from within local Python scripts and notebooks.
-Pythagoras makes data scientists' lives easier, while allowing them to
-solve more complex problems in a shorter time with smaller budgets.
+Pythagoras is a framework for distributed computations in Python.
+
+It offers 3 main advantages:
+
+- Global scale: parallelize your algorithms to scale to millions of nodes.
+- Low maintenance: no need to manage servers and infrastructure,
+Pythagoras replaces expensive compute with cheap storage.
+- High performance: 'compute once, reuse forever' strategy
+significanty accelerates long-running workflows.
+
+Pythagoras is able to offer these benefits as it's the first framework
+to fully implement the Functional Programming 2.0 paradigm.
+
+Pythagoras excels at optimizing complex, long-running,
+resource-demanding computations. It’s not the best choice for real-time,
+latency-sensitive workflows.
 """
 
 
@@ -21,19 +33,3 @@ from ._100_top_level_API import *
 from ._800_signatures_and_converters import *
 
 
-# primary_decorators = {d.__name__:d for d in [
-#     autonomous
-#     , pure
-#     ]}
-#
-# all_decorators = {d.__name__:d for d in [
-#     ordinary
-#     , storable
-#     , logging
-#     , safe
-#     , autonomous
-#     , protected
-#     , pure
-# ]}
-
-

pythagoras/core/__init__.py

@@ -3,4 +3,4 @@ from .._060_autonomous_code_portals import autonomous
 from .._080_pure_code_portals import pure
 from .._090_swarming_portals import SwarmingPortal
 from .._100_top_level_API import get_portal
-from .._070_protected_code_portals import unused_ram, unused_cpu, installed_packages
+from .._070_protected_code_portals.basic_pre_validators import *

{pythagoras-0.22.2.dist-info → pythagoras-0.23.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pythagoras
-Version: 0.22.2
+Version: 0.23.1
 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.22.2.dist-info → pythagoras-0.23.1.dist-info}/RECORD

@@ -1,6 +1,6 @@
 pythagoras/.DS_Store,sha256=40d35c2d6b7fca6728a8be89c610686ceb83b21e32d6fe0ddedcf1b3f58bfdaf,6148
 pythagoras/_010_basic_portals/__init__.py,sha256=111d2457fb61ee16dae275d78e83fe8e837e72a9143281f889148280a50fef96,1703
-pythagoras/_010_basic_portals/basic_portal_core_classes.py,sha256=22bd32244f7d0b118b5eedc8b4ae45c06c47db21942773d7a44a947c52f143ed,18995
+pythagoras/_010_basic_portals/basic_portal_core_classes.py,sha256=9dc857d35e03503710fabb118dea250ac344d19c6865f973d3bdcbdc2c89f841,18996
 pythagoras/_010_basic_portals/exceptions.py,sha256=a15bab585769159db1bedf123bc92e920695f14faa3ad1f4ab0f863b7742b391,237
 pythagoras/_010_basic_portals/long_infoname.py,sha256=9742b2bf023389704c88628a8ed81d1c82ad6eb15a0a27c9cddadbfae1e9cf2d,650
 pythagoras/_010_basic_portals/not_picklable_class.py,sha256=2f7405a32c530a68fae64c5e06731b69c44dea1fc0611e72284d5b13dffd77c0,352
@@ -10,45 +10,45 @@ pythagoras/_020_ordinary_code_portals/__init__.py,sha256=a77912a9a4188f4c65864f4
 pythagoras/_020_ordinary_code_portals/code_normalizer.py,sha256=ecbdcfe40699292f483eaac812fe5425cdc71c33f8f1fc3a1064165d973142d3,5004
 pythagoras/_020_ordinary_code_portals/function_processing.py,sha256=ae5841d1da5a533b6fe92336c2551d6947444dc576a55508098b9f56b40245c7,3623
 pythagoras/_020_ordinary_code_portals/ordinary_decorator.py,sha256=278ab1d37344120a585af8380fc52400bd0f76d02ddac43230dd68a7a2cc16c0,1028
-pythagoras/_020_ordinary_code_portals/ordinary_portal_core_classes.py,sha256=b4de7194d6c70eef172eb1de476515018c5d3eae07c7a15fb574ac6bd963d561,9756
-pythagoras/_030_data_portals/__init__.py,sha256=d149ae2b0bd35429f89fd7922ff407975c3eff4a056ea83919c609d8f20af054,1422
-pythagoras/_030_data_portals/data_portal_core_classes.py,sha256=2e2747fd978d0bce0f0b7f9d6460a4060d092af94a6cd01f5376573e0e5b2cb5,20432
+pythagoras/_020_ordinary_code_portals/ordinary_portal_core_classes.py,sha256=6d8d87cf2d7d9537b3bfde9d49cd65e52b1a1b13643133aaf08b1f9e4755d706,9743
+pythagoras/_030_data_portals/__init__.py,sha256=7ff17d0c29ae5603cc833c118ee363e8523add2de85eeee58f7cd4eba370ec77,1427
+pythagoras/_030_data_portals/data_portal_core_classes.py,sha256=34f1e5235a37747b585d503bcc613f79ab61c4af99fafdfbf707005927a3c2bd,20411
 pythagoras/_030_data_portals/ready_and_get.py,sha256=838004869475dd877a1158a7cb6c20f2f922b97e1ac174286ce30ce287fb6520,2002
 pythagoras/_030_data_portals/storable_decorator.py,sha256=97c5b71a156622c7208e80931aaded99d7a12860cb2159c56d333e196fb51b88,578
-pythagoras/_040_logging_code_portals/__init__.py,sha256=62ff68021e955c0a96ddd89168a3db25a8f20b3384d5e1ca10df7d9a24c96837,1251
-pythagoras/_040_logging_code_portals/exception_processing_tracking.py,sha256=cb280c8390d66e0da2b698f407160573ca1ce49a96c10b7f1f2463a120ebe192,612
+pythagoras/_040_logging_code_portals/__init__.py,sha256=ab6855c8e56013ef51bb7c9c8a52bdf184bd45ab7cb5273a7ab77b02d1b1a5a0,996
+pythagoras/_040_logging_code_portals/exception_processing_tracking.py,sha256=b14f8509acafa6917a81a7c14402ac25c302d0930172708288bceedf2166c620,778
 pythagoras/_040_logging_code_portals/execution_environment_summary.py,sha256=853bd36da75802d8ac6781fcaeafa7fe1b0a3c24b7f23b12cfc970fc0d4322a6,2268
-pythagoras/_040_logging_code_portals/kw_args.py,sha256=8523b445ff1123cb9880147ab2849d7ee8e882a277e697fb33b8d81d2f75445f,2605
+pythagoras/_040_logging_code_portals/kw_args.py,sha256=cf513ce2e8621e13f552e449930c57d4867279f3aa3e7ca0d796197751eae9d7,2604
 pythagoras/_040_logging_code_portals/logging_decorator.py,sha256=d3bf70dbf6791e15c52eb8325d07a48ee39bcbd09d5201541916d14f9969ba35,891
-pythagoras/_040_logging_code_portals/logging_portal_core_classes.py,sha256=197f9471a1f06ef3c40467f53e1ff9a44cc3b6547293c01b0577e639cdd0f566,21872
+pythagoras/_040_logging_code_portals/logging_portal_core_classes.py,sha256=ebc0a18b3f4e85caad69e47c3a244c62e9c42d5aa262c1e34d380620910127e2,21869
 pythagoras/_040_logging_code_portals/notebook_checker.py,sha256=e654090c80f38512114a65f54fcf2701110c10ca030c57f438829cbd3a678739,541
 pythagoras/_040_logging_code_portals/output_capturer.py,sha256=a210a9eaaab12fb22e2467e716e088823e4e7381e60bc73bb99184feecd69199,4216
 pythagoras/_040_logging_code_portals/uncaught_exceptions.py,sha256=0776cfbd7e679c9271e098cb486765d715ce054da9aa8dc23fe32898901f5da1,3121
-pythagoras/_050_safe_code_portals/__init__.py,sha256=d514c7aa066848a9b99c32fa7f8d5d8e5aef6e826f2a5fb1ff8a0bf338753c98,69
-pythagoras/_050_safe_code_portals/safe_decorator.py,sha256=085bb05724d02a3ff4f51708802c2463c4184654b5d008724f7f2b2d0922519c,805
-pythagoras/_050_safe_code_portals/safe_portal_core_classes.py,sha256=bb37bd2515f7982829308265951e4576aed11517b1c8c76de75ef726f96c3ea4,1808
-pythagoras/_060_autonomous_code_portals/__init__.py,sha256=6c19fffb24a93aef9587f0abe9ef24732ef5971c94e9a0fa2c36f4d7a3664e35,2232
-pythagoras/_060_autonomous_code_portals/autonomous_decorators.py,sha256=c315b37cbc30e3929f18e29bda409aad39b6d5d840dcdb8b70c737817d346af6,3947
-pythagoras/_060_autonomous_code_portals/autonomous_portal_core_classes.py,sha256=7b6d8e0c7983e397e919c4c26ecf7642356fe833c90ce393c9d42e95a6f91dd0,5596
-pythagoras/_060_autonomous_code_portals/names_usage_analyzer.py,sha256=1e0e84854ac630b204878fecde48a16739fd2663709fcee2ec0a8844f4fd4f13,7470
-pythagoras/_070_protected_code_portals/OK_const.py,sha256=17ea314496f44b422f9936585c3bb3749c960bc779b4f74962ec04e3fa4d2494,186
-pythagoras/_070_protected_code_portals/__init__.py,sha256=39e7944553dc6d847198e687ebae982bbf5ad8dc366e9fa4dcf60fef73122300,200
-pythagoras/_070_protected_code_portals/basic_pre_validators.py,sha256=742771f96dd635a8d132ac3da90fd17689fe4b38e06160c8019be4fce7ef1602,1441
+pythagoras/_050_safe_code_portals/__init__.py,sha256=611f95e96d96675ed28ea993c98db1758d7ac5354412e2ecd8c75d263fd60995,557
+pythagoras/_050_safe_code_portals/safe_decorator.py,sha256=653b08326b5bdde180592a7074c6174662326898aa57a99d15b07f32a9e0efce,804
+pythagoras/_050_safe_code_portals/safe_portal_core_classes.py,sha256=0f414a7a6f280cddb9a9b55dbb86f7039fcc4e558147d1c1a2704df640de9ecf,2026
+pythagoras/_060_autonomous_code_portals/__init__.py,sha256=7308e1db007167f22096e0c59701784a4ecc5d5fb776ae016a50dc3b6d100285,1747
+pythagoras/_060_autonomous_code_portals/autonomous_decorators.py,sha256=762597d378d96889dce798c0837f75651061f92b797b12512c36624bb76a62f8,2895
+pythagoras/_060_autonomous_code_portals/autonomous_portal_core_classes.py,sha256=89ccd81b5583f263ccde98b73b12ab0d5eeaf19ee31d2c3bad186155f4dc44f8,5968
+pythagoras/_060_autonomous_code_portals/names_usage_analyzer.py,sha256=9aaaf3010c37b46c4f617b0c03c1347e1848a49a29bd116bce47353154ac3d74,7474
+pythagoras/_070_protected_code_portals/__init__.py,sha256=4ef19c25acf6d10aac9aff26da903876e06d167fc274229f9126ce485a094bc9,989
+pythagoras/_070_protected_code_portals/basic_pre_validators.py,sha256=1d63cc3464c602a022e26b74a255c9539ecdb00437c48bb50a41e1e5e443f8f6,1595
 pythagoras/_070_protected_code_portals/fn_arg_names_checker.py,sha256=e858ce5099868030a39057177f93a893e13d7a210582e6ab636aaaccec898fb0,1230
 pythagoras/_070_protected_code_portals/list_flattener.py,sha256=9a54b512ad9dc201db348e7908f5ca5f36d171ae3da433511d38023a6ba8d4b5,331
-pythagoras/_070_protected_code_portals/package_manager.py,sha256=30adf8d75f55b9b2c587dc95f4aa1c2154fa9354d668af6f0d586bb42f0d5b17,2008
-pythagoras/_070_protected_code_portals/protected_decorators.py,sha256=17459a1ad08e3e95f314636e670bce1dcc992631e38d1c08c5e55f3ee1459c2c,1613
-pythagoras/_070_protected_code_portals/protected_portal_core_classes.py,sha256=e8bf525ca65d3520c03e9d35934e62d2edd78c6b3d561b6d9668e1a9a05144e5,8349
+pythagoras/_070_protected_code_portals/package_manager.py,sha256=4111d71886adcf1e8d28f3c2d3a08c8a352601297f9ab3f08a4541586ed9d376,1965
+pythagoras/_070_protected_code_portals/protected_decorators.py,sha256=956ed45870004246d77d6e364015b3a0d936bd8b919dfa9a56c97d69713a9b80,1627
+pythagoras/_070_protected_code_portals/protected_portal_core_classes.py,sha256=a1c4451fa648e05da0376e8ccf27e0e731cfb1d8ea707b33a4ca1f313622de94,9308
 pythagoras/_070_protected_code_portals/system_utils.py,sha256=878a22110140c852b3aaf774cb0c0023458360a4ae221fef89ff3a5d02176301,2360
+pythagoras/_070_protected_code_portals/validation_succesful_const.py,sha256=602cd3598dd43a71421eb547f1e80f411e30df616deb26912a741a2898d06754,300
 pythagoras/_070_protected_code_portals/validator_fn_classes.py,sha256=4afa4bf0629f68e4b1623003272ffd7111ac9cbb739e81fde601049d19b84269,3232
-pythagoras/_080_pure_code_portals/__init__.py,sha256=8ed33435bb03d96675537fc6a696625332f971698d56c6b22b5ca1bc9d1b4274,1856
-pythagoras/_080_pure_code_portals/pure_core_classes.py,sha256=bc84f16c7d410e7fda12231802b7606c690655abbea76523f57f8a6058e0bdfd,19040
-pythagoras/_080_pure_code_portals/pure_decorator.py,sha256=fd7acf43f2735146a4195d2a29d22e545f57b922489cd3baea7d9e4b5b88b5ae,1373
-pythagoras/_090_swarming_portals/__init__.py,sha256=7041578f84ffa291f2752c7a2168007b9113f99482f0173f3729171b3bff551a,32
+pythagoras/_080_pure_code_portals/__init__.py,sha256=aa8564346e1701934310dd5eca92424f5784e0be49c6bad97459f4bab1bdad73,1082
+pythagoras/_080_pure_code_portals/pure_core_classes.py,sha256=5227a65ca50143b0234ce8845d45fad38a7b0b80d7b15ad7f441e594944b59f7,19457
+pythagoras/_080_pure_code_portals/pure_decorator.py,sha256=587650ce6cb1802a402c7aea7de88e32b33a4c391972fd18d9bef9e9ecf84369,2279
+pythagoras/_090_swarming_portals/__init__.py,sha256=4ee035ecf7ed4c1b9da6d01b94db41943e3a06a5228ad92c3ad7f7cb4d502a6d,514
 pythagoras/_090_swarming_portals/output_suppressor.py,sha256=83e6cc9bcc62a226babb1165912ef5095ea948499ce5136a7516ac8b54522607,626
-pythagoras/_090_swarming_portals/swarming_portals.py,sha256=45d50cdc9020742d4dfbf93699f9d1e74ef87ff9cb5931bd3196d0c9d6a6b38e,12003
+pythagoras/_090_swarming_portals/swarming_portals.py,sha256=51e1a4149659cc1ef62761338ae9190736a89ecefc5c10281f20b805f4e4c1d4,12485
 pythagoras/_100_top_level_API/__init__.py,sha256=b392edc2c918da7c2444f14accfd0fac2cd0d5cf6849c64ed2433dfdb58b8b75,64
-pythagoras/_100_top_level_API/default_local_portal.py,sha256=cfbe20499fed2f038b507b44fb58bb4cb6ea2fbe2fe93a3ab5ad7f3ac655005f,215
+pythagoras/_100_top_level_API/default_local_portal.py,sha256=4a7ca44e94d78352ae4f5ab00e7ac067ade562c84ccbed27362520a0e54cc42b,339
 pythagoras/_100_top_level_API/top_level_API.py,sha256=4b63575b86df2fdf28e93c67e8d33411e05bd67cf016d3d297ec9635ebc04081,906
 pythagoras/_800_signatures_and_converters/__init__.py,sha256=d9420254db0c62903fe5419612cef536f219ec319e81b7efc3e783a113aac93b,167
 pythagoras/_800_signatures_and_converters/base_16_32_convertors.py,sha256=66356d2a38e33203201d484cfb543da8b6160832a1965aaaf73e1880a2f4a828,1236
@@ -56,10 +56,10 @@ pythagoras/_800_signatures_and_converters/current_date_gmt_str.py,sha256=2beac61
 pythagoras/_800_signatures_and_converters/hash_signatures.py,sha256=02c5080ff67bc9e174e899a4f2428015722ec6817484dd0ec0e4b54f99eeeff9,989
 pythagoras/_800_signatures_and_converters/node_signatures.py,sha256=2de43f2cc4c3d62f56240fc26fc70668fde809a65f023502fb773ccafae3224b,557
 pythagoras/_800_signatures_and_converters/random_signatures.py,sha256=c174f28c04ccf08c0c5eadaf1e1a00aba4fec88ec370def64afcadd39123141a,323
-pythagoras/_900_project_stats_collector/__init__.py,sha256=e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855,0
-pythagoras/_900_project_stats_collector/project_analyzer.py,sha256=d06e9d7b516cb7424ef777e70abe9d5220e09b0b19476326b8974b4dc3917f89,3506
-pythagoras/__init__.py,sha256=13b5aaf4128704dea052fc03a3a3488f1b14c3638dec45a9a29c74a4fbed7e24,1089
-pythagoras/core/__init__.py,sha256=ec31383ee08c1d6ce12785c5b131a021c6abca933684a6757d8ee4fdc3f0923d,318
-pythagoras-0.22.2.dist-info/WHEEL,sha256=607c46fee47e440c91332c738096ff0f5e54ca3b0818ee85462dd5172a38e793,79
-pythagoras-0.22.2.dist-info/METADATA,sha256=5a0cd5bb24f5e0266b9f1ab67d4df6a2ecefe3a52193e49d1fd977bbb9064c87,4241
-pythagoras-0.22.2.dist-info/RECORD,,
+pythagoras/_900_project_stats_collector/__init__.py,sha256=11a82df8184f3ed046829332c31da590b0cad7ad3763db7f40176d1ca5071c56,71
+pythagoras/_900_project_stats_collector/project_analyzer.py,sha256=ba1c9c14a8d421712961c6589da937ca7e0916172197ea19ef0b7ab291718686,3574
+pythagoras/__init__.py,sha256=4cc3ed25d4a2fd64a10a9267b1555d3b8f1672fb3bf0631b522e601dcd5e30bc,1233
+pythagoras/core/__init__.py,sha256=11c3616471c79550d69a0d3b3b49a45b90087919b82477db5de99c8ebc6ba5c0,298
+pythagoras-0.23.1.dist-info/WHEEL,sha256=607c46fee47e440c91332c738096ff0f5e54ca3b0818ee85462dd5172a38e793,79
+pythagoras-0.23.1.dist-info/METADATA,sha256=4f420f2685e10acb52d4ac4e38ba364e9f5e55be98cc6f222931e34172ce201c,4241
+pythagoras-0.23.1.dist-info/RECORD,,