pythagoras 0.22.1__py3-none-any.whl → 0.23.0__py3-none-any.whl

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}
@@ -139,7 +144,14 @@ class AutonomousFn(SafeFn):
 
 
     def _invalidate_cache(self):
+        """Invalidate the function's attribute cache.
+
+        If the function's attribute named ATTR is cached,
+        its cached value will be stored in an attribute named _ATTR_cache
+        This method should delete all such attributes.
+        """
         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
 
@@ -188,10 +214,18 @@ class ProtectedFn(AutonomousFn):
 
 
     def _invalidate_cache(self):
+        """Invalidate the function's attribute cache.
+
+        If the function's attribute named ATTR is cached,
+        its cached value will be stored in an attribute named _ATTR_cache
+        This method should delete all such attributes.
+        """
         super()._invalidate_cache()
         if hasattr(self, "_post_validators_cached"):
-            assert hasattr(self, "_post_validators_addrs"), "Premature cache invalidation: _post_validators_addrs is missing."
+            assert (hasattr(self, "_post_validators_addrs")
+                , "Premature cache invalidation: _post_validators_addrs is missing.")
             del self._post_validators_cached
         if hasattr(self, "_pre_validators_cached"):
-            assert hasattr(self, "_pre_validators_addrs"), "Premature cache invalidation: _pre_validators_addrs is missing."
+            assert (hasattr(self, "_pre_validators_addrs")
+                , "Premature cache invalidation: _pre_validators_addrs is missing.")
             del self._pre_validators_cached

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
@@ -287,6 +299,7 @@ class PureFnExecutionResultAddr(HashAddr):
             del self._kwargs_cache
         if hasattr(self, "_call_signature_cache"):
             del self._call_signature_cache
+        super()._invalidate_cache()
 
 
     def get_ValueAddr(self):

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
@@ -176,8 +187,15 @@ class SwarmingPortal(PureCodePortal):
 
 
     def _invalidate_cache(self):
+        """Invalidate the object's attribute cache.
+
+        If the object's attribute named ATTR is cached,
+        its cached value will be stored in an attribute named _ATTR_cache
+        This method should delete all such attributes.
+        """
         if hasattr(self, "_max_n_workers_cache"):
             del self._max_n_workers_cache
+        super()._invalidate_cache()
 
 parameterizable.register_parameterizable_class(SwarmingPortal)
 

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,17 @@
-"""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 compute 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,
+we replace expensive compute with cheap storage.
+- High performance: 'compute once, reuse forever' strategy
+significanty accelerates long-running workflows.
+
+Pythagoras is able to affer these benefits as it's the first framework
+to fully implement the Functional Programming 2.0 paradigm.
 """
 
 
@@ -21,19 +29,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.1.dist-info → pythagoras-0.23.0.dist-info}/METADATA

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