pythagoras 0.20.51__py3-none-any.whl → 0.21.0__py3-none-any.whl

pythagoras/_020_ordinary_code_portals/code_normalizer.py

@@ -10,7 +10,15 @@ 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
 
-import pythagoras as pth
+_pythagoras_decorator_names = {
+    "ordinary"
+    , "storable"
+    , "logging"
+    , "safe"
+    , "autonomous"
+    , "protected"
+    , "pure"
+}
 
 def _get_normalized_function_source_impl(
         a_func: Callable | str
@@ -72,13 +80,13 @@ def _get_normalized_function_source_impl(
                 f"Function {a_func_name} can't have multiple decorators,"
                 + " only one decorator is allowed.")
 
-        all_decorators = pth.all_decorators
+        # all_decorators = pth.all_decorators
         # all_decorators = sys.modules['pythagoras'].all_decorators
 
         if drop_pth_decorators and len(decorator_list):
             decorator = decorator_list[0].func
             pth_dec_counter = 0
-            for candidate in all_decorators:
+            for candidate in _pythagoras_decorator_names:
                 try:
                     if decorator.id == candidate:
                         pth_dec_counter += 1

pythagoras/_020_ordinary_code_portals/ordinary_portal_core_classes.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from copy import deepcopy
 from typing import Callable, Any
 
 import pandas as pd
@@ -111,7 +112,9 @@ class OrdinaryFn(PortalAwareClass):
                  ):
         PortalAwareClass.__init__(self, portal=portal)
         if isinstance(fn, OrdinaryFn):
-            self.__setstate__(fn.__getstate__())
+            self.__setstate__(deepcopy(fn.__getstate__()))
+            if self._linked_portal_at_init is None:
+                self._linked_portal_at_init = fn._linked_portal_at_init
             #TODO: check this logic
         else:
             if not (callable(fn) or isinstance(fn, str)):
@@ -264,8 +267,8 @@ class OrdinaryFn(PortalAwareClass):
         self._source_code = state["source_code"]
 
 
-    def __hash_signature_prefix__(self) -> str:
-        prefix = self.name
-        prefix += "_" + self.__class__.__name__
-        prefix = prefix.lower()
-        return prefix
+    def __hash_signature_descriptor__(self) -> str:
+        descriptor = self.name
+        descriptor += "_" + self.__class__.__name__
+        descriptor = descriptor.lower()
+        return descriptor

pythagoras/_030_data_portals/__init__.py

@@ -12,8 +12,8 @@ A ValueAddr is a unique identifier for an immutable value.
 Two objects with exactly the same type and value will always have
 exactly the same ValueAddr-es.
 
-A ValueAddr consists of 2 strings: a prefix, and a hash.
-A prefix contains human-readable information about an object's type.
+A ValueAddr consists of 2 strings: a descriptor, and a hash.
+A descriptor contains human-readable information about an object's type.
 A hash string contains the object's hash signature.
 
 Typically, a DataPortal is implemented as

pythagoras/_030_data_portals/data_portal_core_classes.py

@@ -205,6 +205,8 @@ class StorableFn(OrdinaryFn):
     def _first_visit_to_portal(self, portal: DataPortal) -> None:
         super()._first_visit_to_portal(portal)
         self._persist_initial_config_params(portal)
+        with portal:
+            _ = ValueAddr(self)
 
 
     def _persist_initial_config_params(self, portal:DataPortal) -> None:
@@ -217,11 +219,11 @@ class StorableFn(OrdinaryFn):
         return OrdinaryFn.portal.__get__(self)
 
 
-    @portal.setter
-    def portal(self, new_portal: DataPortal) -> None:
-        if not isinstance(new_portal, DataPortal):
-            raise TypeError("portal must be a DataPortal instance")
-        OrdinaryFn.portal.__set__(self, new_portal)
+    # @portal.setter
+    # def portal(self, new_portal: DataPortal) -> None:
+    #     if not isinstance(new_portal, DataPortal):
+    #         raise TypeError("portal must be a DataPortal instance")
+    #     OrdinaryFn.portal.__set__(self, new_portal)
 
 
     def _get_config_setting(self, key: SafeStrTuple, portal:DataPortal) -> Any:
@@ -284,81 +286,93 @@ class HashAddr(SafeStrTuple):
     Two objects with exactly the same type and value will always have
     exactly the same HashAddr-es.
 
-    A HashAddr consists of 2 components: a prefix, and a hash.
-    A prefix contains human-readable information about an object's type.
-    A hash string contains the object's hash signature. It may begin with
-    an optional descriptor, which provides additional human-readable
+    A HashAddr consists of 2 components: a descriptor, and a hash.
+    A descriptor contains human-readable information about an object's type.
+    A hash string contains the object's hash signature. It may contain
+    an optional suffix, which provides additional human-readable
     information about the object's structure / value.
     """
 
-    def __init__(self, prefix:str
+    def __init__(self, descriptor:str
                  , hash_signature:str):
-        if not isinstance(prefix, str) or not isinstance(hash_signature, str):
-            raise TypeError("prefix and hash_signature must be strings")
-        if len(prefix) == 0 or len(hash_signature) == 0:
-            raise ValueError("prefix and hash_signature must not be empty")
-        SafeStrTuple.__init__(self,prefix,hash_signature)
+        if not isinstance(descriptor, str) or not isinstance(hash_signature, str):
+            raise TypeError("descriptor and hash_signature must be strings")
+        if len(descriptor) == 0 or len(hash_signature) == 0:
+            raise ValueError("descriptor and hash_signature must not be empty")
+        SafeStrTuple.__init__(self,hash_signature[:3], hash_signature[3:6]
+                              ,descriptor, hash_signature[6:])
 
 
     @property
-    def prefix(self) -> str:
+    def shard(self)->str:
         return self.strings[0]
 
     @property
-    def hash_signature(self) -> str:
+    def subshard(self)->str:
         return self.strings[1]
 
+    @property
+    def descriptor(self) -> str:
+        return self.strings[2]
+
+    @property
+    def hash_tail(self)->str:
+        return self.strings[3]
+
+    @property
+    def hash_signature(self) -> str:
+        return self.shard+self.subshard+self.hash_tail
+
     @staticmethod
-    def _build_prefix(x: Any) -> str:
+    def _build_descriptor(x: Any) -> str:
         """Create a short human-readable summary of an object."""
 
-        if (hasattr(x, "__hash_signature_prefix__")
-                and callable(x.__hash_signature_prefix__)):
-            prfx = x.__hash_signature_prefix__()
+        if (hasattr(x, "__hash_signature_descriptor__")
+                and callable(x.__hash_signature_descriptor__)):
+            descriptor = x.__hash_signature_descriptor__()
         else:
-            prfx = x.__class__.__name__.lower()
+            descriptor = x.__class__.__name__.lower()
+            if (hasattr(x, "shape") and hasattr(x.shape, "__iter__")
+                    and callable(x.shape.__iter__) and not callable(x.shape)):
+                suffix, connector = "_shape_", "_x_"
+                for n in x.shape:
+                    suffix += str(n) + connector
+                suffix = suffix[:-len(connector)]
+            elif hasattr(x, "__len__") and callable(x.__len__):
+                suffix = "_len_" + str(len(x))
+            else:
+                suffix = ""
+
+            suffix = replace_unsafe_chars(suffix, replace_with="_")
+            descriptor = descriptor + suffix
 
-        return prfx
+        return descriptor
 
 
     @staticmethod
     def _build_hash_signature(x: Any) -> str:
         """Create a URL-safe hashdigest for an object."""
-
-        if (hasattr(x, "shape") and hasattr(x.shape, "__iter__")
-                and callable(x.shape.__iter__) and not callable(x.shape)):
-            descriptor, connector = "shape_", "_x_"
-            for n in x.shape:
-                descriptor += str(n) + connector
-            descriptor = descriptor[:-len(connector)] + "_"
-        elif hasattr(x, "__len__") and callable(x.__len__):
-            descriptor = "len_" + str(len(x)) + "_"
-        else:
-            descriptor = ""
-
-        descriptor = replace_unsafe_chars(descriptor, replace_with="_")
-        raw_hash_signature = get_hash_signature(x)
-        hash_signature = descriptor + raw_hash_signature
-
+        hash_signature = get_hash_signature(x)
         return hash_signature
 
 
     @classmethod
     def from_strings(cls, *
-                     , prefix:str
+                     , descriptor:str
                      , hash_signature:str
                      , assert_readiness:bool=True
                      ) -> HashAddr:
-        """(Re)construct address from text representations of prefix and hash"""
+        """(Re)construct address from text representations of descriptor and hash"""
 
-        if not isinstance(prefix, str) or not isinstance(hash_signature, str):
-            raise TypeError("prefix and hash_signature must be strings")
+        if not isinstance(descriptor, str) or not isinstance(hash_signature, str):
+            raise TypeError("descriptor and hash_signature must be strings")
 
-        if len(prefix) == 0 or len(hash_signature) == 0:
-            raise ValueError("prefix and hash_signature must not be empty")
+        if len(descriptor) == 0 or len(hash_signature) == 0:
+            raise ValueError("descriptor and hash_signature must not be empty")
 
         address = cls.__new__(cls)
-        super(cls, address).__init__(prefix, hash_signature)
+        super(cls, address).__init__(descriptor=descriptor
+            , hash_signature=hash_signature)
         if assert_readiness:
             if not address.ready:
                 raise ValueError("Address is not ready for retrieving data")
@@ -407,7 +421,7 @@ class ValueAddr(HashAddr):
     uniquely address all possible data objects that the humanity  will create
     in the foreseeable future (see, for example ipfs.io).
 
-    However, an address also includes a prefix and an optional descriptor.
+    However, an address also includes a descriptor with an optional suffix.
     It makes it easier for humans to interpret an address,
     and further decreases collision risk.
     """
@@ -419,22 +433,22 @@ class ValueAddr(HashAddr):
 
         if hasattr(data, "get_ValueAddr"):
             data_value_addr = data.get_ValueAddr()
-            prefix = data_value_addr.prefix
+            descriptor = data_value_addr.descriptor
             hash_signature = data_value_addr.hash_signature
             HashAddr.__init__(self
-                , prefix=prefix
-                , hash_signature=hash_signature)
+                              , descriptor=descriptor
+                              , hash_signature=hash_signature)
             return
 
         assert not isinstance(data, HashAddr), (
                 "get_ValueAddr is the only way to "
                 + "convert HashAddr into ValueAddr")
 
-        prefix = self._build_prefix(data)
+        descriptor = self._build_descriptor(data)
         hash_signature = self._build_hash_signature(data)
         HashAddr.__init__(self
-            , prefix=prefix
-            , hash_signature=hash_signature)
+                          , descriptor=descriptor
+                          , hash_signature=hash_signature)
 
         self._value_cache = data
 
@@ -563,13 +577,13 @@ class ValueAddr(HashAddr):
 
     @classmethod
     def from_strings(cls, *
-                     , prefix: str
+                     , descriptor: str
                      , hash_signature: str
                      , assert_readiness: bool = True
                      ) -> HashAddr:
-        """(Re)construct address from text representations of prefix and hash"""
+        """(Re)construct address from text representations of descriptor and hash"""
 
-        address = super().from_strings(prefix=prefix, 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/kw_args.py

@@ -59,13 +59,17 @@ class KwArgs(dict):
         return unpacked_copy
 
 
-    def pack(self) -> PackedKwArgs:
+    def pack(self, store = True) -> PackedKwArgs:
         """ Replace values with their hash addresses."""
-        portal = get_active_portal()
         packed_copy = dict()
-        with portal:
-            for k,v in self.items():
-                packed_copy[k] = ValueAddr(v)
+        if store:
+            portal = get_active_portal()
+            with portal:
+                for k,v in self.items():
+                    packed_copy[k] = ValueAddr(v,store=True)
+        else:
+            for k, v in self.items():
+                packed_copy[k] = ValueAddr(v, store=False)
         packed_copy = PackedKwArgs(**packed_copy)
         return packed_copy
 

pythagoras/_040_logging_code_portals/logging_portal_core_classes.py

@@ -40,11 +40,16 @@ class LoggingFn(StorableFn):
             , excessive_logging: bool|Joker = KEEP_CURRENT
             , portal: LoggingCodePortal | None = None
             ):
+        super().__init__(fn=fn, portal=portal)
+
         if not isinstance(excessive_logging, (bool, Joker)):
             raise TypeError(
                 "excessive_logging must be a boolean or Joker, "
                 f"got {type(excessive_logging)}")
-        StorableFn.__init__(self, fn=fn, portal=portal)
+
+        if excessive_logging is KEEP_CURRENT and isinstance(fn, LoggingFn):
+            excessive_logging = fn._ephemeral_config_params_at_init["excessive_logging"]
+
         self._ephemeral_config_params_at_init[
             "excessive_logging"] = excessive_logging
 
@@ -70,12 +75,6 @@ class LoggingFn(StorableFn):
         return StorableFn.portal.__get__(self)
 
 
-    # @portal.setter
-    # def portal(self, new_portal: LoggingCodePortal) -> None:
-    #     if not isinstance(new_portal, LoggingCodePortal):
-    #         raise TypeError("portal must be a LoggingCodePortal instance")
-    #     StorableFn.portal.__set__(self, new_portal)
-
 
 class LoggingFnCallSignature:
     """A signature of a call to a (logging) function.
@@ -113,16 +112,16 @@ class LoggingFnCallSignature:
     def __getstate__(self):
         """This method is called when the object is pickled."""
         state = dict(
-            _fn_addr=self._fn_addr
-            , _kwargs_addr=self._kwargs_addr)
+            fn_addr=self._fn_addr
+            , kwargs_addr=self._kwargs_addr)
         return state
 
 
     def __setstate__(self, state):
         """This method is called when the object is unpickled."""
         self._invalidate_cache()
-        self._fn_addr = state["_fn_addr"]
-        self._kwargs_addr = state["_kwargs_addr"]
+        self._fn_addr = state["fn_addr"]
+        self._kwargs_addr = state["kwargs_addr"]
 
 
     def _invalidate_cache(self):
@@ -181,11 +180,11 @@ class LoggingFnCallSignature:
         return self.fn.excessive_logging
 
 
-    def __hash_signature_prefix__(self) -> str:
-        prefix = self.fn_name
-        prefix += "_" + self.__class__.__name__
-        prefix = prefix.lower()
-        return prefix
+    def __hash_signature_descriptor__(self) -> str:
+        descriptor = self.fn_name
+        descriptor += "_" + self.__class__.__name__
+        descriptor = descriptor.lower()
+        return descriptor
 
 
     def execute(self) -> Any:

pythagoras/_060_autonomous_code_portals/autonomous_portal_core_classes.py

@@ -4,7 +4,8 @@ import builtins
 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 .._040_logging_code_portals import KwArgs
 
 from .._060_autonomous_code_portals.names_usage_analyzer import (
@@ -31,34 +32,37 @@ class AutonomousCodePortal(SafeCodePortal):
 
 class AutonomousFn(SafeFn):
 
-    _fixed_kwargs: KwArgs | None
+    _fixed_kwargs_cached: KwArgs | None
+    _fixed_kwargs_packed: KwArgs | None
 
     def __init__(self, fn: Callable|str|SafeFn
                  , fixed_kwargs: dict|None = None
                  , excessive_logging: bool|Joker = KEEP_CURRENT
                  , portal: AutonomousCodePortal|None = None):
-        SafeFn.__init__(self
-            ,fn=fn
+        super().__init__(fn=fn
             , portal = portal
             , excessive_logging = excessive_logging)
 
+        fixed_kwargs = dict() if fixed_kwargs is None else fixed_kwargs
+        fixed_kwargs = KwArgs(**fixed_kwargs)
+        fixed_kwargs_packed = fixed_kwargs.pack(store=False)
+
         if isinstance(fn, AutonomousFn):
-            assert fixed_kwargs is None
-            assert isinstance(self._fixed_kwargs, KwArgs)
-            return
+            self._fixed_kwargs_packed.update(fixed_kwargs_packed)
+            self._fixed_kwargs_cached = KwArgs(**{**fn.fixed_kwargs, **fixed_kwargs})
+        else:
+            self._fixed_kwargs_cached = fixed_kwargs
+            self._fixed_kwargs_packed = fixed_kwargs_packed
 
         fn_name = self.name
 
-        fixed_kwargs = dict() if fixed_kwargs is None else fixed_kwargs
-        self._fixed_kwargs = KwArgs(fixed_kwargs)
-
         analyzer = analyze_names_in_function(self.source_code)
         normalized_source = analyzer["normalized_source"]
         analyzer = analyzer["analyzer"]
         assert self.source_code == normalized_source
 
         nonlocal_names = analyzer.names.explicitly_nonlocal_unbound_deep
-        all_decorators = pth.all_decorators
+        all_decorators = _pythagoras_decorator_names
         # all_decorators = sys.modules["pythagoras"].all_decorators
         nonlocal_names -= set(all_decorators) #????????????
 
@@ -71,7 +75,8 @@ class AutonomousFn(SafeFn):
 
         import_required = analyzer.names.explicitly_global_unbound_deep
         import_required |= analyzer.names.unclassified_deep
-        import_required -= set(pth.primary_decorators)
+        # import_required -= set(pth.primary_decorators)
+        import_required -= {"pure", "autonomous"}
         builtin_names = set(dir(builtins))
         import_required -= builtin_names
         pth_names = set(self._available_names())
@@ -84,35 +89,48 @@ class AutonomousFn(SafeFn):
             + f" without importing them inside the function body")
 
 
+    @property
+    def fixed_kwargs(self) -> KwArgs:
+        if not hasattr(self, "_fixed_kwargs_cached"):
+            with self.portal:
+                self._fixed_kwargs_cached = self._fixed_kwargs_packed.unpack()
+        return self._fixed_kwargs_cached
+
+
     def execute(self, **kwargs) -> Any:
         with self.portal:
-            overlapping_keys = set(kwargs.keys()) & set(self._fixed_kwargs.keys())
+            overlapping_keys = set(kwargs.keys()) & set(self.fixed_kwargs.keys())
             assert len(overlapping_keys) == 0
-            kwargs.update(self._fixed_kwargs)
-            return SafeFn.execute(self, **kwargs)
+            kwargs.update(self.fixed_kwargs)
+            return super().execute(**kwargs)
 
 
     def fix_kwargs(self, **kwargs) -> AutonomousFn:
-        overlapping_keys = set(kwargs.keys()) & set(self._fixed_kwargs.keys())
+        overlapping_keys = set(kwargs.keys()) & set(self.fixed_kwargs.keys())
         assert len(overlapping_keys) == 0
-        new_fixed_kwargs = self._fixed_kwargs.copy()
-        new_fixed_kwargs.update(kwargs)
-        new_fn = AutonomousFn(self.source_code
-                              , fixed_kwargs=new_fixed_kwargs
-                              , portal=self._linked_portal)
+        new_fixed_kwargs = {**self.fixed_kwargs,**kwargs}
+        new_fn = type(self)(fn=self, fixed_kwargs=new_fixed_kwargs)
         return new_fn
 
 
+    def _first_visit_to_portal(self, portal: DataPortal) -> None:
+        super()._first_visit_to_portal(portal)
+        if hasattr(self,"_fixed_kwargs_cached"):
+            with portal:
+                _ = self._fixed_kwargs_cached.pack()
+
+
     def __getstate__(self):
         """This method is called when the object is pickled."""
         state = super().__getstate__()
-        state["_fixed_kwargs"] = self._fixed_kwargs
+        state["fixed_kwargs_packed"] = self._fixed_kwargs_packed
         return state
 
+
     def __setstate__(self, state):
         """This method is called when the object is unpickled."""
         super().__setstate__(state)
-        self._fixed_kwargs = state["_fixed_kwargs"]
+        self._fixed_kwargs_packed = state["fixed_kwargs_packed"]
 
 
     @property
@@ -120,8 +138,8 @@ class AutonomousFn(SafeFn):
         return SafeFn.portal.__get__(self)
 
 
-    # @portal.setter
-    # def portal(self, new_portal: AutonomousCodePortal) -> None:
-    #     if not isinstance(new_portal, AutonomousCodePortal):
-    #         raise TypeError("portal must be a AutonomousCodePortal instance")
-    #     SafeFn.portal.__set__(self, new_portal)
+    def _invalidate_cache(self):
+        super()._invalidate_cache()
+        if hasattr(self, "_fixed_kwargs_cached"):
+            assert hasattr(self, "_fixed_kwargs_packed"), "Premature cache invalidation: fixed_kwargs_packed is missing."
+            del self._fixed_kwargs_cached

pythagoras/_070_protected_code_portals/RAM_pre_validators.py

@@ -0,0 +1,58 @@
+from .._060_autonomous_code_portals import autonomous
+from .OK_const import OK, OKClass
+from .system_utils import *
+
+
+# def free_ram_bytes(packed_kwargs, fn_addr, required_memory):
+#     import psutil
+#     mem_info = psutil.virtual_memory()
+#     if mem_info.available >= required_memory:
+#         return OK
+#
+#
+# def RAM_K(limit:int) -> AutonomousFn:
+#     global free_ram_bytes
+#     if not isinstance(free_ram_bytes, AutonomousFn):
+#         free_ram_bytes = autonomous()(free_ram_bytes)
+#     limit = int(limit/1024)
+#     assert limit > 0
+#     return free_ram_bytes.fix_kwargs(required_memory = limit)
+#
+#
+# def RAM_M(limit:int) -> AutonomousFn:
+#     limit = int(limit/1024)
+#     return RAM_K(limit)
+#
+#
+# def RAM_G(limit:int) -> AutonomousFn:
+#     limit = int(limit/1024)
+#     return RAM_M(limit)
+#
+#
+# def RAM_T(limit:int) -> AutonomousFn:
+#     limit = int(limit/1024)
+#     return RAM_G(limit)
+
+@autonomous()
+def at_least_X_G_RAM_free_check(x:int)->bool|OKClass:
+    ram = pth.get_available_ram_mb()/1024
+    if ram >= x:
+        return pth.OK
+    else:
+        return False
+
+def at_least_X_G_RAM_free(x:int):
+    assert isinstance(x, int)
+    assert x > 0
+    return at_least_X_G_RAM_free_check.fix_kwargs(x=x)
+
+at_least_1_G_RAM_free = at_least_X_G_RAM_free(x=1)
+at_least_2_G_RAM_free = at_least_X_G_RAM_free(x=2)
+at_least_4_G_RAM_free = at_least_X_G_RAM_free(x=4)
+at_least_8_G_RAM_free = at_least_X_G_RAM_free(x=8)
+at_least_16_G_RAM_free = at_least_X_G_RAM_free(x=16)
+at_least_32_G_RAM_free = at_least_X_G_RAM_free(x=32)
+at_least_64_G_RAM_free = at_least_X_G_RAM_free(x=64)
+at_least_128_G_RAM_free = at_least_X_G_RAM_free(x=128)
+at_least_256_G_RAM_free = at_least_X_G_RAM_free(x=256)
+at_least_512_G_RAM_free = at_least_X_G_RAM_free(x=512)

pythagoras/_070_protected_code_portals/__init__.py

@@ -1,6 +1,7 @@
 from .OK_const import *
 from .protected_portal_core_classes import *
 from .protected_decorators import *
-from .GPU_guards import *
-from .python_packages_guards import *
-from .RAM_guards import *
+from .GPU_pre_validators import *
+from .python_packages_pre_validators import *
+from .RAM_pre_validators import *
+from .system_utils import *

pythagoras/_070_protected_code_portals/fn_arg_names_checker.py

@@ -1,7 +1,8 @@
 import ast
-from typing import List
+from typing import List, Set
 
-def check_if_fn_accepts_args(required_arg_names: List[str], fn: str) -> bool:
+
+def check_if_fn_accepts_args(required_arg_names: List[str]|Set[str], fn: str) -> bool:
     """
     Analyzes the source code (string) `fn` of a Python function and determines
     if it can accept the arguments named in `required_arg_names`.

pythagoras/_070_protected_code_portals/protected_decorators.py

@@ -2,18 +2,19 @@
 
 from typing import Callable
 
-from .._060_autonomous_code_portals import autonomous, AutonomousFn
+from .validator_fn_classes import ValidatorFn
+from .._060_autonomous_code_portals import autonomous
 from .protected_portal_core_classes import ProtectedFn, ProtectedCodePortal
 from persidict import Joker, KEEP_CURRENT
 
 class protected(autonomous):
 
-    _guards: list[AutonomousFn] | None
-    _validators: list[AutonomousFn] | None
+    _pre_validators: list[ValidatorFn] | None
+    _post_validators: list[ValidatorFn] | None
 
     def __init__(self
-                 , guards: list[AutonomousFn] | None = None
-                 , validators: list[AutonomousFn] | None = None
+                 , pre_validators: list[ValidatorFn] | None = None
+                 , post_validators: list[ValidatorFn] | None = None
                  , fixed_kwargs: dict | None = None
                  , excessive_logging: bool|Joker = KEEP_CURRENT
                  , portal: ProtectedCodePortal | None = None
@@ -24,15 +25,15 @@ class protected(autonomous):
             , portal=portal
             , excessive_logging=excessive_logging
             , fixed_kwargs=fixed_kwargs)
-        self._guards = guards
-        self._validators = validators
+        self._pre_validators = pre_validators
+        self._post_validators = post_validators
 
 
     def __call__(self, fn: Callable|str) -> ProtectedFn:
         wrapper = ProtectedFn(fn
-            ,portal=self._portal
-            ,guards=self._guards
-            ,fixed_kwargs=self._fixed_kwargs
-            ,validators=self._validators
-            ,excessive_logging=self._excessive_logging)
+                              , portal=self._portal
+                              , pre_validators=self._pre_validators
+                              , fixed_kwargs=self._fixed_kwargs
+                              , post_validators=self._post_validators
+                              , excessive_logging=self._excessive_logging)
         return wrapper