From 8bf8fcea32e5cf0654e2692b2f219d81c736941a Mon Sep 17 00:00:00 2001 From: timotheyca Date: Mon, 11 Jul 2022 19:54:46 +0300 Subject: [PATCH] change import structure --- plot.py | 2 + rainbowadn/atomic/__init__.py | 12 ++- rainbowadn/chain/__init__.py | 18 +++- rainbowadn/chain/blockchain.py | 46 +++------ rainbowadn/chain/blockchainprotocol.py | 14 +-- rainbowadn/chain/blockcollectioninterface.py | 17 +--- rainbowadn/chain/chaincollectionfactory.py | 9 +- rainbowadn/chain/chaincollectioninterface.py | 8 +- rainbowadn/chain/derivation/__init__.py | 18 +++- rainbowadn/chain/reduction/__init__.py | 21 +++-- .../abstractreductionchainmetafactory.py | 2 +- .../chain/reduction/reductionchainprotocol.py | 17 +--- rainbowadn/chain/reductionchainmetafactory.py | 3 +- rainbowadn/chain/stages/__init__.py | 8 +- rainbowadn/chain/stages/stagestate.py | 5 +- rainbowadn/chain/states/__init__.py | 6 ++ rainbowadn/collection/comparison/__init__.py | 15 ++- .../collection/comparison/comparator.py | 9 +- rainbowadn/collection/linear/__init__.py | 12 ++- .../collection/linear/treelist/__init__.py | 7 +- .../collection/trees/binary/__init__.py | 12 ++- .../trees/binary/actions/__init__.py | 12 ++- .../collection/trees/binary/core/__init__.py | 9 ++ rainbowadn/core/__init__.py | 51 ++++++---- rainbowadn/encryption/__init__.py | 6 +- rainbowadn/encryption/encrypted.py | 2 +- rainbowadn/flow/bridge/__init__.py | 10 +- rainbowadn/flow/bridge/_stagebridge.py | 34 ++++++- rainbowadn/flow/bridge/_statebridge.py | 94 +++++++++++++++++++ rainbowadn/flow/core/__init__.py | 18 +++- rainbowadn/flow/sequence/__init__.py | 12 ++- rainbowadn/flow/stacked/__init__.py | 9 +- rainbowadn/flow/verification/core/__init__.py | 15 ++- .../flow/verification/stages/__init__.py | 9 +- .../flow/verification/stateverification.py | 3 + rainbowadn/instrument/__init__.py | 15 ++- rainbowadn/nullability/__init__.py | 15 ++- rainbowadn/testing/resolvers/__init__.py | 18 +++- rainbowadn/testing/resolvers/failresolver.py | 2 + rainbowadn/testing/test_bridge.py | 16 ++-- rainbowadn/testing/test_encryption.py | 14 +-- rainbowadn/testing/test_trees.py | 23 ++--- rainbowadn/testing/test_v13.py | 10 +- rainbowadn/toplevel/__init__.py | 9 +- rainbowadn/v13/__init__.py | 18 +++- rainbowadn/v13/bankchain.py | 1 - rainbowadn/wrisbt/__init__.py | 12 ++- rainbowadn/wrisbt/wrisbtchainprotocol.py | 12 +-- trace.py | 18 ++-- 49 files changed, 477 insertions(+), 251 deletions(-) create mode 100644 rainbowadn/flow/bridge/_statebridge.py diff --git a/plot.py b/plot.py index 5ae73e1..6efc191 100644 --- a/plot.py +++ b/plot.py @@ -4,6 +4,8 @@ from pathlib import Path import matplotlib.pyplot as plt import numpy as np +__all__ = ('plot',) + def plottable(log: list[tuple[float, int]]): if log: diff --git a/rainbowadn/atomic/__init__.py b/rainbowadn/atomic/__init__.py index 5948d05..2278b91 100644 --- a/rainbowadn/atomic/__init__.py +++ b/rainbowadn/atomic/__init__.py @@ -1,3 +1,9 @@ -from .atomic import * -from .integer import * -from .plain import * +__all__ = ( + 'Atomic', + 'Integer', + 'Plain', +) + +from .atomic import Atomic +from .integer import Integer +from .plain import Plain diff --git a/rainbowadn/chain/__init__.py b/rainbowadn/chain/__init__.py index 57e090d..890cd1a 100644 --- a/rainbowadn/chain/__init__.py +++ b/rainbowadn/chain/__init__.py @@ -1,5 +1,13 @@ -from .blockchain import * -from .blockchainprotocol import * -from .chaincollectionfactory import * -from .chaincollectioninterface import * -from .reductionchainmetafactory import * +__all__ = ( + 'BlockChain', 'BlockChainFactory', + 'BlockChainProtocol', + 'ChainCollectionFactory', + 'ChainCollectionInterface', + 'ReductionChainMetaFactory', +) + +from .blockchain import BlockChain, BlockChainFactory +from .blockchainprotocol import BlockChainProtocol +from .chaincollectionfactory import ChainCollectionFactory +from .chaincollectioninterface import ChainCollectionInterface +from .reductionchainmetafactory import ReductionChainMetaFactory diff --git a/rainbowadn/chain/blockchain.py b/rainbowadn/chain/blockchain.py index 4cb9bda..ebac815 100644 --- a/rainbowadn/chain/blockchain.py +++ b/rainbowadn/chain/blockchain.py @@ -11,7 +11,6 @@ __all__ = ('BlockChain', 'BlockChainFactory',) HeaderType = TypeVar('HeaderType') StateType = TypeVar('StateType') -ActualStateType = TypeVar('ActualStateType') class BlockChain( @@ -20,10 +19,9 @@ class BlockChain( HeaderType, StateType ], - HeaderType, - ActualStateType + HeaderType ], - Generic[HeaderType, ActualStateType, StateType], + Generic[HeaderType, StateType], ): def __init__( self, @@ -33,7 +31,7 @@ class BlockChain( StateType ] ], - protocol: BlockChainProtocol[HeaderType, StateType, ActualStateType], + protocol: BlockChainProtocol[HeaderType, StateType], ): assert isinstance(reference, NullableReference) assert isinstance(protocol, BlockChainProtocol) @@ -45,8 +43,7 @@ class BlockChain( HeaderType, StateType ], - HeaderType, - ActualStateType + HeaderType ]: return BlockChainFactory(self.protocol) @@ -58,8 +55,7 @@ class BlockChain( HeaderType, StateType ], - HeaderType, - ActualStateType + HeaderType ]: assert isinstance(header, HashPoint) return self.factory().from_reference( @@ -107,8 +103,7 @@ class BlockChain( HeaderType, StateType ], - HeaderType, - ActualStateType + HeaderType ]: assert not self.reference.null() block: Block[ @@ -123,7 +118,7 @@ class BlockChain( return True else: previous: ChainCollectionInterface[ - Block[HeaderType, StateType], HeaderType, ActualStateType + Block[HeaderType, StateType], HeaderType ] = await self.previous() assert isinstance(previous, ChainCollectionInterface) assert_trues( @@ -161,26 +156,12 @@ class BlockChain( ) return True - def _actual_state_factory(self) -> RainbowFactory[ActualStateType]: - return self.protocol.actual_state_factory() - - async def _actual_state( - self, - block: Block[ - HeaderType, - StateType - ] - ) -> HashPoint[ActualStateType]: - assert isinstance(block, Block) - return await self.protocol.actual_state(await block.state.resolve()) - def loose(self) -> ChainCollectionInterface[ Block[ HeaderType, StateType ], - HeaderType, - ActualStateType + HeaderType ]: return self @@ -191,19 +172,18 @@ class BlockChainFactory( HeaderType, StateType ], - HeaderType, - ActualStateType + HeaderType ], - Generic[HeaderType, ActualStateType, StateType] + Generic[HeaderType, StateType] ): def __init__( self, - protocol: BlockChainProtocol[HeaderType, StateType, ActualStateType], + protocol: BlockChainProtocol[HeaderType, StateType], ): assert isinstance(protocol, BlockChainProtocol) self.protocol = protocol - def empty(self) -> BlockChain[HeaderType, ActualStateType, StateType]: + def empty(self) -> BlockChain[HeaderType, StateType]: return BlockChain( NullableReference( Null(), @@ -224,7 +204,7 @@ class BlockChainFactory( ], ] ) -> BlockChain[ - HeaderType, ActualStateType, StateType + HeaderType, StateType ]: assert isinstance(reference, NullableReference) return BlockChain( diff --git a/rainbowadn/chain/blockchainprotocol.py b/rainbowadn/chain/blockchainprotocol.py index d1d00c9..ceae56a 100644 --- a/rainbowadn/chain/blockchainprotocol.py +++ b/rainbowadn/chain/blockchainprotocol.py @@ -7,11 +7,10 @@ __all__ = ('BlockChainProtocol',) HeaderType = TypeVar('HeaderType') StateType = TypeVar('StateType') -ActualStateType = TypeVar('ActualStateType') class BlockChainProtocol( - Generic[HeaderType, StateType, ActualStateType], + Generic[HeaderType, StateType], ): def __init__( self, @@ -26,14 +25,5 @@ class BlockChainProtocol( self.header_factory = header_factory self.state_factory = state_factory - def actual_state_factory(self) -> RainbowFactory[ActualStateType]: - raise NotImplementedError - - async def actual_state( - self, - state: StateType - ) -> HashPoint[ActualStateType]: - raise NotImplementedError - - def loose(self) -> 'BlockChainProtocol[HeaderType, StateType, ActualStateType]': + def loose(self) -> 'BlockChainProtocol[HeaderType, StateType]': return self diff --git a/rainbowadn/chain/blockcollectioninterface.py b/rainbowadn/chain/blockcollectioninterface.py index c06c47b..d04b037 100644 --- a/rainbowadn/chain/blockcollectioninterface.py +++ b/rainbowadn/chain/blockcollectioninterface.py @@ -8,14 +8,13 @@ __all__ = ('BlockCollectionInterface',) BlockType = TypeVar('BlockType') HeaderType = TypeVar('HeaderType') -ActualStateType = TypeVar('ActualStateType') class BlockCollectionInterface( CollectionInterface[ BlockType ], - Generic[BlockType, HeaderType, ActualStateType] + Generic[BlockType, HeaderType] ): def __init__( self, @@ -44,20 +43,8 @@ class BlockCollectionInterface( previous ) - def _actual_state_factory(self) -> RainbowFactory[ActualStateType]: - raise NotImplementedError - - async def _actual_state(self, block: BlockType) -> HashPoint[ActualStateType]: - raise NotImplementedError - - async def actual_state(self) -> NullableReference[ActualStateType]: - if self.reference.null(): - return NullableReference(Null(), self._actual_state_factory()) - else: - return NullableReference.of(await self._actual_state(await self.reference.resolve())) - async def add( self, header: HashPoint[HeaderType] - ) -> 'BlockCollectionInterface[BlockType, HeaderType, ActualStateType]': + ) -> 'BlockCollectionInterface[BlockType, HeaderType]': raise NotImplementedError diff --git a/rainbowadn/chain/chaincollectionfactory.py b/rainbowadn/chain/chaincollectionfactory.py index bcee69e..575ceaa 100644 --- a/rainbowadn/chain/chaincollectionfactory.py +++ b/rainbowadn/chain/chaincollectionfactory.py @@ -7,18 +7,17 @@ __all__ = ('ChainCollectionFactory',) BlockType = TypeVar('BlockType') HeaderType = TypeVar('HeaderType') -ActualStateType = TypeVar('ActualStateType') -class ChainCollectionFactory(Generic[BlockType, HeaderType, ActualStateType]): - def empty(self) -> ChainCollectionInterface[BlockType, HeaderType, ActualStateType]: +class ChainCollectionFactory(Generic[BlockType, HeaderType]): + def empty(self) -> ChainCollectionInterface[BlockType, HeaderType]: raise NotImplementedError def from_reference( self, reference: NullableReference[BlockType] - ) -> ChainCollectionInterface[BlockType, HeaderType, ActualStateType]: + ) -> ChainCollectionInterface[BlockType, HeaderType]: raise NotImplementedError - def loose(self) -> 'ChainCollectionFactory[BlockType, HeaderType, ActualStateType]': + def loose(self) -> 'ChainCollectionFactory[BlockType, HeaderType]': return self diff --git a/rainbowadn/chain/chaincollectioninterface.py b/rainbowadn/chain/chaincollectioninterface.py index 5a8156e..ae9c860 100644 --- a/rainbowadn/chain/chaincollectioninterface.py +++ b/rainbowadn/chain/chaincollectioninterface.py @@ -8,22 +8,20 @@ __all__ = ('ChainCollectionInterface',) BlockType = TypeVar('BlockType') HeaderType = TypeVar('HeaderType') -ActualStateType = TypeVar('ActualStateType') class ChainCollectionInterface( BlockCollectionInterface[ BlockType, - HeaderType, - ActualStateType + HeaderType ], - Generic[BlockType, HeaderType, ActualStateType], + Generic[BlockType, HeaderType], abc.ABC ): async def add( self, header: HashPoint[HeaderType] - ) -> 'ChainCollectionInterface[BlockType, HeaderType, ActualStateType]': + ) -> 'ChainCollectionInterface[BlockType, HeaderType]': raise NotImplementedError async def verify(self) -> bool: diff --git a/rainbowadn/chain/derivation/__init__.py b/rainbowadn/chain/derivation/__init__.py index 9524632..ca0aed4 100644 --- a/rainbowadn/chain/derivation/__init__.py +++ b/rainbowadn/chain/derivation/__init__.py @@ -1,5 +1,13 @@ -from .activestageprotocol import * -from .activestagestateprotocol import * -from .derived import * -from .derivedstage import * -from .derivedstate import * +__all__ = ( + 'ActiveStageProtocol', + 'ActiveStageStateProtocol', + 'Derived', + 'DerivedStage', + 'DerivedState', +) + +from .activestageprotocol import ActiveStageProtocol +from .activestagestateprotocol import ActiveStageStateProtocol +from .derived import Derived +from .derivedstage import DerivedStage +from .derivedstate import DerivedState diff --git a/rainbowadn/chain/reduction/__init__.py b/rainbowadn/chain/reduction/__init__.py index fb099fa..5ce68b4 100644 --- a/rainbowadn/chain/reduction/__init__.py +++ b/rainbowadn/chain/reduction/__init__.py @@ -1,6 +1,15 @@ -from .abstractreductionchainmetafactory import * -from .reduced import * -from .reducible import * -from .reductionchainprotocol import * -from .reductionprotocol import * -from .reductionresult import * +__all__ = ( + 'AbstractReductionChainMetaFactory', + 'Reduced', + 'Reducible', 'ReducibleFactory', + 'ReductionChainProtocol', + 'ReductionProtocol', + 'ReductionResult', +) + +from .abstractreductionchainmetafactory import AbstractReductionChainMetaFactory +from .reduced import Reduced +from .reducible import Reducible, ReducibleFactory +from .reductionchainprotocol import ReductionChainProtocol +from .reductionprotocol import ReductionProtocol +from .reductionresult import ReductionResult diff --git a/rainbowadn/chain/reduction/abstractreductionchainmetafactory.py b/rainbowadn/chain/reduction/abstractreductionchainmetafactory.py index fed2052..5b83e9a 100644 --- a/rainbowadn/chain/reduction/abstractreductionchainmetafactory.py +++ b/rainbowadn/chain/reduction/abstractreductionchainmetafactory.py @@ -20,6 +20,6 @@ class AbstractReductionChainMetaFactory( accumulator_factory: RainbowFactory[AccumulatorType], protocol: ReductionProtocol[ReductorType, AccumulatorType], ) -> ChainCollectionFactory[ - BlockType, ReductorType, AccumulatorType + BlockType, ReductorType ]: raise NotImplementedError diff --git a/rainbowadn/chain/reduction/reductionchainprotocol.py b/rainbowadn/chain/reduction/reductionchainprotocol.py index 20cfd42..e7cafa5 100644 --- a/rainbowadn/chain/reduction/reductionchainprotocol.py +++ b/rainbowadn/chain/reduction/reductionchainprotocol.py @@ -17,8 +17,7 @@ AccumulatorType = TypeVar('AccumulatorType') class ReductionChainProtocol( BlockChainProtocol[ ReductorType, - StateStage[ReductorType, AccumulatorType, Reducible[ReductorType, AccumulatorType]], - AccumulatorType + StateStage[ReductorType, AccumulatorType, Reducible[ReductorType, AccumulatorType]] ] ): def __init__( @@ -60,17 +59,3 @@ class ReductionChainProtocol( self.reductor_factory = reductor_factory self.accumulator_factory = accumulator_factory - - def actual_state_factory(self) -> RainbowFactory[AccumulatorType]: - return self.accumulator_factory - - async def actual_state( - self, - state: StateStage[ - ReductorType, - AccumulatorType, - Reducible[ReductorType, AccumulatorType] - ] - ) -> HashPoint[AccumulatorType]: - assert isinstance(state, StateStage) - return state.state diff --git a/rainbowadn/chain/reductionchainmetafactory.py b/rainbowadn/chain/reductionchainmetafactory.py index 4b5dd17..84373da 100644 --- a/rainbowadn/chain/reductionchainmetafactory.py +++ b/rainbowadn/chain/reductionchainmetafactory.py @@ -34,8 +34,7 @@ class ReductionChainMetaFactory( ReductorType, StateStage[ReductorType, AccumulatorType, Reducible[ReductorType, AccumulatorType]] ], - ReductorType, - AccumulatorType + ReductorType ]: assert isinstance(reductor_factory, RainbowFactory) assert isinstance(accumulator_factory, RainbowFactory) diff --git a/rainbowadn/chain/stages/__init__.py b/rainbowadn/chain/stages/__init__.py index 9152258..bd05068 100644 --- a/rainbowadn/chain/stages/__init__.py +++ b/rainbowadn/chain/stages/__init__.py @@ -1,3 +1,9 @@ +__all__ = ( + 'StageProtocol', + 'StageStage', 'StageStageFactory', 'StateStage', 'StateStageFactory', + 'StageStateProtocol', +) + from .stageprotocol import StageProtocol -from .stagestate import * +from .stagestate import StageStage, StageStageFactory, StateStage, StateStageFactory from .stagestateprotocol import StageStateProtocol diff --git a/rainbowadn/chain/stages/stagestate.py b/rainbowadn/chain/stages/stagestate.py index 9d7e695..48c4b7e 100644 --- a/rainbowadn/chain/stages/stagestate.py +++ b/rainbowadn/chain/stages/stagestate.py @@ -5,10 +5,7 @@ from rainbowadn.nullability import * from .stageprotocol import * __all__ = ( - 'StageStage', - 'StageStageFactory', - 'StateStage', - 'StateStageFactory', + 'StageStage', 'StageStageFactory', 'StateStage', 'StateStageFactory', ) HeaderType = TypeVar('HeaderType') diff --git a/rainbowadn/chain/states/__init__.py b/rainbowadn/chain/states/__init__.py index 3fb61f1..891bc4f 100644 --- a/rainbowadn/chain/states/__init__.py +++ b/rainbowadn/chain/states/__init__.py @@ -1,3 +1,9 @@ +__all__ = ( + 'ActiveStateProtocol', + 'MetaReductionStateProtocol', + 'StateProtocol', +) + from .activestateprotocol import ActiveStateProtocol from .metareductionstateprotocol import MetaReductionStateProtocol from .stateprotocol import StateProtocol diff --git a/rainbowadn/collection/comparison/__init__.py b/rainbowadn/collection/comparison/__init__.py index 6e654b6..a9df17b 100644 --- a/rainbowadn/collection/comparison/__init__.py +++ b/rainbowadn/collection/comparison/__init__.py @@ -1,4 +1,11 @@ -from .comparator import * -from .hashcomparator import * -from .keyedcomparator import * -from .plaincomparator import * +__all__ = ( + 'Comparison', 'Left', 'Right', 'Equal', 'Replace', 'Fail', 'Duplicate', 'Comparator', + 'HashComparator', + 'KeyedComparator', + 'PlainComparator', +) + +from .comparator import Comparator, Comparison, Duplicate, Equal, Fail, Left, Replace, Right +from .hashcomparator import HashComparator +from .keyedcomparator import KeyedComparator +from .plaincomparator import PlainComparator diff --git a/rainbowadn/collection/comparison/comparator.py b/rainbowadn/collection/comparison/comparator.py index b45e9a5..72f115a 100644 --- a/rainbowadn/collection/comparison/comparator.py +++ b/rainbowadn/collection/comparison/comparator.py @@ -4,14 +4,7 @@ from typing import Generic, TypeVar from rainbowadn.core import * __all__ = ( - 'Comparison', - 'Left', - 'Right', - 'Equal', - 'Replace', - 'Fail', - 'Duplicate', - 'Comparator', + 'Comparison', 'Left', 'Right', 'Equal', 'Replace', 'Fail', 'Duplicate', 'Comparator', ) diff --git a/rainbowadn/collection/linear/__init__.py b/rainbowadn/collection/linear/__init__.py index c1c67a2..5c10e58 100644 --- a/rainbowadn/collection/linear/__init__.py +++ b/rainbowadn/collection/linear/__init__.py @@ -1,3 +1,9 @@ -from .array import * -from .stack import * -from .treelist import * +__all__ = ( + 'Array', 'ArrayFactory', + 'Stack', 'StackFactory', + 'TLRoot', 'TLRootFactory', 'TLRParametres', +) + +from .array import Array, ArrayFactory +from .stack import Stack, StackFactory +from .treelist import TLRParametres, TLRoot, TLRootFactory diff --git a/rainbowadn/collection/linear/treelist/__init__.py b/rainbowadn/collection/linear/treelist/__init__.py index 9c9abaf..bde1635 100644 --- a/rainbowadn/collection/linear/treelist/__init__.py +++ b/rainbowadn/collection/linear/treelist/__init__.py @@ -1,2 +1,7 @@ -from .tlroot import * +__all__ = ( + 'TLRoot', 'TLRootFactory', + 'TLRParametres', +) + +from .tlroot import TLRoot, TLRootFactory from .tlrparametres import TLRParametres diff --git a/rainbowadn/collection/trees/binary/__init__.py b/rainbowadn/collection/trees/binary/__init__.py index 1eb6fa9..7ca31ec 100644 --- a/rainbowadn/collection/trees/binary/__init__.py +++ b/rainbowadn/collection/trees/binary/__init__.py @@ -1,3 +1,9 @@ -from .activebinarytree import * -from .avl import * -from .binarytree import * +__all__ = ( + 'ActiveBinaryTree', + 'AVL', + 'BinaryTree', 'BinaryTreeFactory', +) + +from .activebinarytree import ActiveBinaryTree +from .avl import AVL +from .binarytree import BinaryTree, BinaryTreeFactory diff --git a/rainbowadn/collection/trees/binary/actions/__init__.py b/rainbowadn/collection/trees/binary/actions/__init__.py index b8bc143..8f3e8a3 100644 --- a/rainbowadn/collection/trees/binary/actions/__init__.py +++ b/rainbowadn/collection/trees/binary/actions/__init__.py @@ -1,3 +1,9 @@ -from .binaryaction import * -from .stdactions import * -from .symmetric import * +__all__ = ( + 'BinaryAction', + 'AddAction', 'RemoveAction', 'ContainsAction', + 'Symmetric', 'InnerOuter', 'OuterInner', +) + +from .binaryaction import BinaryAction +from .stdactions import AddAction, ContainsAction, RemoveAction +from .symmetric import InnerOuter, OuterInner, Symmetric diff --git a/rainbowadn/collection/trees/binary/core/__init__.py b/rainbowadn/collection/trees/binary/core/__init__.py index 3b31f8c..9afa057 100644 --- a/rainbowadn/collection/trees/binary/core/__init__.py +++ b/rainbowadn/collection/trees/binary/core/__init__.py @@ -1,3 +1,12 @@ +__all__ = ( + 'BalancedCreation', + 'BinaryBalancing', + 'BinaryCreation', + 'BinaryProtocolized', + 'BinarySplit', + 'ProtocolizedBinarySplit', +) + from .balancedcreation import BalancedCreation from .binarybalancing import BinaryBalancing from .binarycreation import BinaryCreation diff --git a/rainbowadn/core/__init__.py b/rainbowadn/core/__init__.py index 094f9fc..3b07854 100644 --- a/rainbowadn/core/__init__.py +++ b/rainbowadn/core/__init__.py @@ -1,16 +1,35 @@ -from .asserts import * -from .extendableresolver import * -from .gather import * -from .hash_point_format import * -from .hashpoint import * -from .hashresolver import * -from .localmetaorigin import * -from .localorigin import * -from .mentionable import * -from .metaorigin import * -from .origin import * -from .rainbow_factory import * -from .recursivementionable import * -from .resolvermetaorigin import * -from .resolverorigin import * -from .static import * +__all__ = ( + 'assert_true', 'assert_trues', 'assert_false', 'assert_none', 'assert_none_strict', 'assert_eq', + 'ExtendableResolver', + 'gather', 'asum', 'alist', 'set_gather_asyncio', 'set_gather_linear', + 'hash_point_format', 'tabulate', + 'HashPoint', + 'HashResolver', + 'LocalMetaOrigin', + 'LocalOrigin', + 'Mentionable', + 'MetaOrigin', + 'Origin', + 'RainbowFactory', + 'RecursiveMentionable', + 'ResolverMetaOrigin', + 'ResolverOrigin', + 'StaticMentionable', 'StaticFactory', +) + +from .asserts import assert_eq, assert_false, assert_none, assert_none_strict, assert_true, assert_trues +from .extendableresolver import ExtendableResolver +from .gather import alist, asum, gather, set_gather_asyncio, set_gather_linear +from .hash_point_format import hash_point_format, tabulate +from .hashpoint import HashPoint +from .hashresolver import HashResolver +from .localmetaorigin import LocalMetaOrigin +from .localorigin import LocalOrigin +from .mentionable import Mentionable +from .metaorigin import MetaOrigin +from .origin import Origin +from .rainbow_factory import RainbowFactory +from .recursivementionable import RecursiveMentionable +from .resolvermetaorigin import ResolverMetaOrigin +from .resolverorigin import ResolverOrigin +from .static import StaticFactory, StaticMentionable diff --git a/rainbowadn/encryption/__init__.py b/rainbowadn/encryption/__init__.py index 6b79479..03dba0b 100644 --- a/rainbowadn/encryption/__init__.py +++ b/rainbowadn/encryption/__init__.py @@ -1 +1,5 @@ -from .encrypted import * +__all__ = ( + 'Encrypted', 'EncryptedFactory', +) + +from .encrypted import Encrypted, EncryptedFactory diff --git a/rainbowadn/encryption/encrypted.py b/rainbowadn/encryption/encrypted.py index e1bb0cc..b5c7c3a 100644 --- a/rainbowadn/encryption/encrypted.py +++ b/rainbowadn/encryption/encrypted.py @@ -5,7 +5,7 @@ from nacl.secret import SecretBox from rainbowadn.core import * -__all__ = ('Encrypted', 'EncryptedFactory') +__all__ = ('Encrypted', 'EncryptedFactory',) EncryptedType = TypeVar('EncryptedType') diff --git a/rainbowadn/flow/bridge/__init__.py b/rainbowadn/flow/bridge/__init__.py index 8cf9727..2d8a082 100644 --- a/rainbowadn/flow/bridge/__init__.py +++ b/rainbowadn/flow/bridge/__init__.py @@ -1,5 +1,11 @@ """a bridge between old .chain and new .flow todo: deprecate """ -from ._stackbridge import * -from ._stagebridge import * + +__all__ = ( + 'StackBridge', + 'StageBridgeVP', 'StageBridgeM', 'stage_bridge', +) + +from ._stackbridge import StackBridge +from ._stagebridge import StageBridgeM, StageBridgeVP, stage_bridge diff --git a/rainbowadn/flow/bridge/_stagebridge.py b/rainbowadn/flow/bridge/_stagebridge.py index e40fd06..b78bc15 100644 --- a/rainbowadn/flow/bridge/_stagebridge.py +++ b/rainbowadn/flow/bridge/_stagebridge.py @@ -6,11 +6,12 @@ from rainbowadn.collection.pair import * from rainbowadn.core import * from rainbowadn.flow.core import * from rainbowadn.flow.sequence import * +from rainbowadn.flow.verification.core import * from rainbowadn.flow.verification.stages import * from rainbowadn.nullability import * from ._stackbridge import * -__all__ = ('StageBridgeVP', 'StageBridgeM',) +__all__ = ('StageBridgeVP', 'StageBridgeM', 'stage_bridge',) BaseT = TypeVar('BaseT') StageT = TypeVar('StageT') @@ -69,3 +70,34 @@ class StageBridgeM( stack_bridge: Reducer[SequenceDispatcher[HashPoint[StageT], bool], bool] = StackBridge(stages_stack).loose() assert isinstance(stack_bridge, Reducer) return base, stack_bridge + + +def stage_bridge( + stage_protocol: StageProtocol[HeaderT, BaseT, StageT], base_factory: RainbowFactory[BaseT] +) -> Verification[ + tuple[ + Nullable[HashPoint[Pair[BaseT, Stack[StageT]]]], + HashPoint[HeaderT], + HashPoint[Pair[BaseT, Stack[StageT]]] + ] +]: + assert isinstance(stage_protocol, StageProtocol) + assert isinstance(base_factory, RainbowFactory) + vp: StageVerificationProtocol[ + HashPoint[BaseT], HashPoint[StageT], HashPoint[HeaderT] + ] = StageBridgeVP(stage_protocol, base_factory) + assert isinstance(vp, StageVerificationProtocol) + m: Mapper[ + HashPoint[Pair[BaseT, Stack[StageT]]], + tuple[HashPoint[BaseT], Reducer[SequenceDispatcher[HashPoint[StageT], bool], bool]] + ] = StageBridgeM() + assert isinstance(m, Mapper) + v: Verification[ + tuple[ + Nullable[HashPoint[Pair[BaseT, Stack[StageT]]]], + HashPoint[HeaderT], + HashPoint[Pair[BaseT, Stack[StageT]]] + ] + ] = StageVerification(vp, m).loose() + assert isinstance(v, Verification) + return v diff --git a/rainbowadn/flow/bridge/_statebridge.py b/rainbowadn/flow/bridge/_statebridge.py new file mode 100644 index 0000000..1510bef --- /dev/null +++ b/rainbowadn/flow/bridge/_statebridge.py @@ -0,0 +1,94 @@ +from typing import Generic, TypeVar + +from rainbowadn.chain.states import * +from rainbowadn.collection.pair import * +from rainbowadn.core import * +from rainbowadn.flow.core import * +from rainbowadn.flow.verification.core import * +from rainbowadn.flow.verification.stateverification import * +from rainbowadn.nullability import * + +__all__ = ('StateBridgeM', 'StateBridgeV',) + +HeaderT = TypeVar('HeaderT') +StateT = TypeVar('StateT') + + +class StateBridgeM( + Mapper[ + HashPoint[Pair[HeaderT, StateT]], + tuple[HashPoint[HeaderT], HashPoint[StateT]], + ], + Generic[HeaderT, StateT] +): + async def map( + self, + element: HashPoint[Pair[HeaderT, StateT]] + ) -> tuple[HashPoint[HeaderT], HashPoint[StateT]]: + assert isinstance(element, HashPoint) + resolved = await element.resolve() + header: HashPoint[HeaderT] = resolved.element0 + assert isinstance(header, HashPoint) + state: HashPoint[StateT] = resolved.element1 + assert isinstance(state, HashPoint) + return header, state + + +class StateBridgeV( + Verification[ + tuple[Nullable[HashPoint[StateT]], HashPoint[HeaderT], HashPoint[StateT]] + ], + Generic[HeaderT, StateT] +): + def __init__(self, protocol: StateProtocol[HeaderT, StateT]): + assert isinstance(protocol, StateProtocol) + self.protocol = protocol + + async def verify( + self, + element: tuple[Nullable[HashPoint[StateT]], HashPoint[HeaderT], HashPoint[StateT]] + ) -> bool: + assert isinstance(element, tuple) + previous: Nullable[HashPoint[StateT]] + header: HashPoint[HeaderT] + state: HashPoint[StateT] + previous, header, state = element + assert isinstance(previous, Nullable) + assert isinstance(header, HashPoint) + assert isinstance(state, HashPoint) + assert_true( + await self.protocol.verify( + NullableReference(previous, state.factory), + header, + state + ) + ) + return True + + +def state_bridge( + protocol: StateProtocol[HeaderT, StateT] +) -> Verification[ + tuple[ + Nullable[HashPoint[Pair[HeaderT, StateT]]], + HashPoint[Pair[HeaderT, StateT]] + ] +]: + assert isinstance(protocol, StateProtocol) + m: Mapper[ + HashPoint[Pair[HeaderT, StateT]], + tuple[HashPoint[HeaderT], HashPoint[StateT]], + ] = StateBridgeM() + assert isinstance(m, Mapper) + sv: Verification[ + tuple[Nullable[HashPoint[StateT]], HashPoint[HeaderT], HashPoint[StateT]] + ] = StateBridgeV(protocol) + assert isinstance(sv, Verification) + v: Verification[ + tuple[ + Nullable[HashPoint[Pair[HeaderT, StateT]]], + HashPoint[Pair[HeaderT, StateT]] + ] + ] = StateVerification(m, sv).loose() + assert isinstance(v, Verification) + return v diff --git a/rainbowadn/flow/core/__init__.py b/rainbowadn/flow/core/__init__.py index 5816591..3a3f75f 100644 --- a/rainbowadn/flow/core/__init__.py +++ b/rainbowadn/flow/core/__init__.py @@ -1,5 +1,13 @@ -from ._mapper import * -from ._mapreduce import * -from ._mapreducer import * -from ._reduce import * -from ._reducer import * +__all__ = ( + 'Mapper', + 'MapReduce', + 'MapReducer', + 'Reduce', + 'Reducer', +) + +from ._mapper import Mapper +from ._mapreduce import MapReduce +from ._mapreducer import MapReducer +from ._reduce import Reduce +from ._reducer import Reducer diff --git a/rainbowadn/flow/sequence/__init__.py b/rainbowadn/flow/sequence/__init__.py index c9faa43..95a5d72 100644 --- a/rainbowadn/flow/sequence/__init__.py +++ b/rainbowadn/flow/sequence/__init__.py @@ -1,3 +1,9 @@ -from ._dispatchmapper import * -from ._sequencedispatch import * -from ._sequencedispatcher import * +__all__ = ( + 'DispatchMapper', + 'SequenceDispatch', + 'SequenceDispatcher', 'FirstDispatcher', 'LastDispatcher', 'PairDispatcher', +) + +from ._dispatchmapper import DispatchMapper +from ._sequencedispatch import SequenceDispatch +from ._sequencedispatcher import FirstDispatcher, LastDispatcher, PairDispatcher, SequenceDispatcher diff --git a/rainbowadn/flow/stacked/__init__.py b/rainbowadn/flow/stacked/__init__.py index 7bc41d5..ad8de28 100644 --- a/rainbowadn/flow/stacked/__init__.py +++ b/rainbowadn/flow/stacked/__init__.py @@ -1,2 +1,7 @@ -from ._stackedreduce import * -from ._stackedreducer import * +__all__ = ( + 'StackedReduce', + 'StackedReducer', +) + +from ._stackedreduce import StackedReduce +from ._stackedreducer import StackedReducer diff --git a/rainbowadn/flow/verification/core/__init__.py b/rainbowadn/flow/verification/core/__init__.py index 27d8874..1aa6137 100644 --- a/rainbowadn/flow/verification/core/__init__.py +++ b/rainbowadn/flow/verification/core/__init__.py @@ -1,4 +1,11 @@ -from ._mapperverification import * -from ._reduceverification import * -from ._verification import * -from ._verifyreduce import * +__all__ = ( + 'MapperVerification', + 'ReduceVerification', + 'Verification', + 'VerifyReduce', +) + +from ._mapperverification import MapperVerification +from ._reduceverification import ReduceVerification +from ._verification import Verification +from ._verifyreduce import VerifyReduce diff --git a/rainbowadn/flow/verification/stages/__init__.py b/rainbowadn/flow/verification/stages/__init__.py index b622329..1dc8555 100644 --- a/rainbowadn/flow/verification/stages/__init__.py +++ b/rainbowadn/flow/verification/stages/__init__.py @@ -1,2 +1,7 @@ -from ._stageverification import * -from ._stageverificationprotocol import * +__all__ = ( + 'StageVerification', + 'StageVerificationProtocol', +) + +from ._stageverification import StageVerification +from ._stageverificationprotocol import StageVerificationProtocol diff --git a/rainbowadn/flow/verification/stateverification.py b/rainbowadn/flow/verification/stateverification.py index 915a6fd..986e3c3 100644 --- a/rainbowadn/flow/verification/stateverification.py +++ b/rainbowadn/flow/verification/stateverification.py @@ -55,3 +55,6 @@ class StateVerification( assert isinstance(element, tuple) assert_true(await self.verification.map(await self._tuple(element))) return True + + def loose(self) -> Verification[tuple[Nullable[Chain], Chain]]: + return self diff --git a/rainbowadn/instrument/__init__.py b/rainbowadn/instrument/__init__.py index 719f934..740123e 100644 --- a/rainbowadn/instrument/__init__.py +++ b/rainbowadn/instrument/__init__.py @@ -1,4 +1,11 @@ -from .concurrency import * -from .counter import * -from .entryexit import * -from .instrumentation import * +__all__ = ( + 'Concurrency', + 'Counter', + 'EntryExit', + 'Instrumentation', +) + +from .concurrency import Concurrency +from .counter import Counter +from .entryexit import EntryExit +from .instrumentation import Instrumentation diff --git a/rainbowadn/nullability/__init__.py b/rainbowadn/nullability/__init__.py index a307b26..33bd0e2 100644 --- a/rainbowadn/nullability/__init__.py +++ b/rainbowadn/nullability/__init__.py @@ -1,4 +1,11 @@ -from .notnull import * -from .null import * -from .nullable import * -from .nullablereference import * +__all__ = ( + 'NotNull', + 'Null', + 'Nullable', + 'NullableReference', 'NullableReferenceFactory', +) + +from .notnull import NotNull +from .null import Null +from .nullable import Nullable +from .nullablereference import NullableReference, NullableReferenceFactory diff --git a/rainbowadn/testing/resolvers/__init__.py b/rainbowadn/testing/resolvers/__init__.py index a815a81..dab4b59 100644 --- a/rainbowadn/testing/resolvers/__init__.py +++ b/rainbowadn/testing/resolvers/__init__.py @@ -1,5 +1,13 @@ -from .cachingresolver import * -from .defaultresolver import * -from .delayedresolver import * -from .dictresolver import * -from .failresolver import * +__all__ = ( + 'CachingResolver', + 'default_resolver', + 'DelayedResolver', + 'DictResolver', + 'FailResolver', +) + +from .cachingresolver import CachingResolver +from .defaultresolver import default_resolver +from .delayedresolver import DelayedResolver +from .dictresolver import DictResolver +from .failresolver import FailResolver diff --git a/rainbowadn/testing/resolvers/failresolver.py b/rainbowadn/testing/resolvers/failresolver.py index 97b19dc..39514b5 100644 --- a/rainbowadn/testing/resolvers/failresolver.py +++ b/rainbowadn/testing/resolvers/failresolver.py @@ -1,5 +1,7 @@ from rainbowadn.core import * +__all__ = ('FailResolver',) + class FailResolver(HashResolver): async def resolve(self, point: bytes) -> tuple[bytes, 'HashResolver']: diff --git a/rainbowadn/testing/test_bridge.py b/rainbowadn/testing/test_bridge.py index b3d48cf..4c877de 100644 --- a/rainbowadn/testing/test_bridge.py +++ b/rainbowadn/testing/test_bridge.py @@ -1,13 +1,13 @@ import unittest -from rainbowadn.atomic import Plain -from rainbowadn.collection.linear import Stack -from rainbowadn.core import HashPoint, assert_none_strict, hash_point_format -from rainbowadn.flow.bridge import StackBridge -from rainbowadn.flow.core import MapReduce, Reduce -from rainbowadn.flow.sequence import DispatchMapper, SequenceDispatch -from rainbowadn.flow.stacked import StackedReducer -from rainbowadn.nullability import Nullable +from rainbowadn.atomic import * +from rainbowadn.collection.linear import * +from rainbowadn.core import * +from rainbowadn.flow.bridge import * +from rainbowadn.flow.core import * +from rainbowadn.flow.sequence import * +from rainbowadn.flow.stacked import * +from rainbowadn.nullability import * class PrintDispatch(SequenceDispatch[HashPoint, None]): diff --git a/rainbowadn/testing/test_encryption.py b/rainbowadn/testing/test_encryption.py index 486b853..2ec618c 100644 --- a/rainbowadn/testing/test_encryption.py +++ b/rainbowadn/testing/test_encryption.py @@ -1,13 +1,13 @@ import string import unittest -from rainbowadn.atomic import Integer, Plain -from rainbowadn.collection.comparison import PlainComparator, Replace -from rainbowadn.collection.trees.binary import AVL, ActiveBinaryTree -from rainbowadn.core import HashPoint, set_gather_linear -from rainbowadn.encryption import Encrypted -from rainbowadn.instrument import Counter -from rainbowadn.testing.resolvers import default_resolver +from rainbowadn.atomic import * +from rainbowadn.collection.comparison import * +from rainbowadn.collection.trees.binary import * +from rainbowadn.core import * +from rainbowadn.encryption import * +from rainbowadn.instrument import * +from rainbowadn.testing.resolvers import * class TestEncryption(unittest.IsolatedAsyncioTestCase): diff --git a/rainbowadn/testing/test_trees.py b/rainbowadn/testing/test_trees.py index 8dd7294..bc9cfb0 100644 --- a/rainbowadn/testing/test_trees.py +++ b/rainbowadn/testing/test_trees.py @@ -3,17 +3,14 @@ import time import unittest from typing import Any -from rainbowadn.atomic import Integer, Plain -from rainbowadn.chain import BlockChainFactory, ChainCollectionInterface -from rainbowadn.collection.comparison import PlainComparator, Replace -from rainbowadn.collection.pair import Pair, PairFactory -from rainbowadn.collection.trees.binary import AVL, ActiveBinaryTree -from rainbowadn.core import ( - HashPoint, RainbowFactory, assert_eq, assert_false, assert_true, set_gather_asyncio, - set_gather_linear, -) -from rainbowadn.testing.resolvers import default_resolver -from rainbowadn.wrisbt import WrisbtChainProtocol, WrisbtParametres, WrisbtRoot +from rainbowadn.atomic import * +from rainbowadn.chain import * +from rainbowadn.collection.comparison import * +from rainbowadn.collection.pair import * +from rainbowadn.collection.trees.binary import * +from rainbowadn.core import * +from rainbowadn.testing.resolvers import * +from rainbowadn.wrisbt import * class TestTrees(unittest.IsolatedAsyncioTestCase): @@ -79,10 +76,6 @@ class TestTrees(unittest.IsolatedAsyncioTestCase): with self.subTest('check'): set_gather_asyncio() assert_true(await chain.verify()) - with self.subTest('measure height'): - reference = await chain.actual_state() - assert not reference.null() - print((await reference.resolve()).height) async def test_avl(self): set_gather_linear() diff --git a/rainbowadn/testing/test_v13.py b/rainbowadn/testing/test_v13.py index 0d4a14d..906f78d 100644 --- a/rainbowadn/testing/test_v13.py +++ b/rainbowadn/testing/test_v13.py @@ -2,11 +2,11 @@ import unittest import nacl.signing -from rainbowadn.chain import ReductionChainMetaFactory -from rainbowadn.core import HashPoint, assert_true, set_gather_asyncio, set_gather_linear -from rainbowadn.nullability import NotNull -from rainbowadn.testing.resolvers import default_resolver -from rainbowadn.v13 import BankChain, CoinData, MINT_CONST, Subject, Transaction +from rainbowadn.chain import * +from rainbowadn.core import * +from rainbowadn.nullability import * +from rainbowadn.testing.resolvers import * +from rainbowadn.v13 import * class TestV13(unittest.IsolatedAsyncioTestCase): diff --git a/rainbowadn/toplevel/__init__.py b/rainbowadn/toplevel/__init__.py index f2248cf..6616f5b 100644 --- a/rainbowadn/toplevel/__init__.py +++ b/rainbowadn/toplevel/__init__.py @@ -1,2 +1,7 @@ -from .thresholdprotocol import * -from .validreference import * +__all__ = ( + 'ThresholdProtocol', + 'ValidReference', 'ValidReferenceFactory', +) + +from .thresholdprotocol import ThresholdProtocol +from .validreference import ValidReference, ValidReferenceFactory diff --git a/rainbowadn/v13/__init__.py b/rainbowadn/v13/__init__.py index 8114a64..717e375 100644 --- a/rainbowadn/v13/__init__.py +++ b/rainbowadn/v13/__init__.py @@ -1,5 +1,13 @@ -from .algo import * -from .bankchain import * -from .signature import * -from .subject import * -from .transaction import * +__all__ = ( + 'MINT_CONST', + 'BankChain', + 'BadSignature', 'Signature', + 'Subject', + 'CoinData', 'Coin', 'TransactionData', 'Transaction', +) + +from .algo import MINT_CONST +from .bankchain import BankChain +from .signature import BadSignature, Signature +from .subject import Subject +from .transaction import Coin, CoinData, Transaction, TransactionData diff --git a/rainbowadn/v13/bankchain.py b/rainbowadn/v13/bankchain.py index cc7ab58..6f0f79b 100644 --- a/rainbowadn/v13/bankchain.py +++ b/rainbowadn/v13/bankchain.py @@ -20,7 +20,6 @@ class BankChain(Generic[BlockType]): chain: ChainCollectionInterface[ BlockType, NullableReference[Stack[Transaction]], - BankState, ] ): assert isinstance(chain, ChainCollectionInterface) diff --git a/rainbowadn/wrisbt/__init__.py b/rainbowadn/wrisbt/__init__.py index 0e3bec8..58e8c86 100644 --- a/rainbowadn/wrisbt/__init__.py +++ b/rainbowadn/wrisbt/__init__.py @@ -1,3 +1,9 @@ -from .wrisbtchainprotocol import * -from .wrisbtparametres import * -from .wrisbtroot import * +__all__ = ( + 'WrisbtChainProtocol', + 'WrisbtParametres', + 'WrisbtRoot', 'WrisbtRootFactory', +) + +from .wrisbtchainprotocol import WrisbtChainProtocol +from .wrisbtparametres import WrisbtParametres +from .wrisbtroot import WrisbtRoot, WrisbtRootFactory diff --git a/rainbowadn/wrisbt/wrisbtchainprotocol.py b/rainbowadn/wrisbt/wrisbtchainprotocol.py index 07dc44b..05b33c6 100644 --- a/rainbowadn/wrisbt/wrisbtchainprotocol.py +++ b/rainbowadn/wrisbt/wrisbtchainprotocol.py @@ -3,9 +3,7 @@ from typing import Generic, TypeVar from rainbowadn.chain import * from rainbowadn.core import * from .wrisbtindex import * -from .wrisbtparametres import * from .wrisbtprotocol import * -from .wrisbtroot import * __all__ = ('WrisbtChainProtocol',) @@ -15,8 +13,7 @@ TargetType = TypeVar('TargetType') class WrisbtChainProtocol( BlockChainProtocol[ TargetType, - WrisbtIndex, - WrisbtRoot + WrisbtIndex ], Generic[TargetType] ): @@ -35,10 +32,3 @@ class WrisbtChainProtocol( WrisbtIndexFactory(keymin) ) self.total_factory = total_factory - - def actual_state_factory(self) -> RainbowFactory[WrisbtRoot]: - return WrisbtRootFactory(WrisbtParametres(self.keymin, HashPoint.HASH_LENGTH)) - - async def actual_state(self, state: WrisbtIndex) -> HashPoint[WrisbtRoot]: - assert isinstance(state, WrisbtIndex) - return state.total diff --git a/trace.py b/trace.py index 3284a2f..1d28e77 100644 --- a/trace.py +++ b/trace.py @@ -8,15 +8,15 @@ from contextlib import ExitStack from nacl.signing import SigningKey -from plot import plot -from rainbowadn.chain import ReductionChainMetaFactory -from rainbowadn.collection.linear import Stack -from rainbowadn.collection.trees.binary import ActiveBinaryTree -from rainbowadn.core import ExtendableResolver, HashPoint, assert_true, set_gather_asyncio, set_gather_linear -from rainbowadn.instrument import Concurrency, Counter, EntryExit, Instrumentation -from rainbowadn.nullability import NotNull -from rainbowadn.testing.resolvers import DelayedResolver, DictResolver -from rainbowadn.v13 import BankChain, CoinData, MINT_CONST, Subject, Transaction +from plot import * +from rainbowadn.chain import * +from rainbowadn.collection.linear import * +from rainbowadn.collection.trees.binary import * +from rainbowadn.core import * +from rainbowadn.instrument import * +from rainbowadn.nullability import * +from rainbowadn.testing.resolvers import * +from rainbowadn.v13 import * def get_dr() -> ExtendableResolver: