Signature, TargetAddress, TokenAddress, TokenAmount, TokenNetworkAddress, TokenNetworkID, TransactionHash, Tuple, Type, TypeVar, ) EMPTY = "empty" GENERATE = "generate" K = TypeVar("K") V = TypeVar("V") def _partial_dict(full_dict: Dict[K, V], *args) -> Dict[K, V]: return {key: full_dict[key] for key in args} class Properties: """ Base class for all properties classes. """ DEFAULTS: ClassVar["Properties"] = None TARGET_TYPE: ClassVar[Type] = None @property def kwargs(self):
Iterator, List, NamedTuple, NewType, Optional, RaidenDBVersion, Tuple, Type, TypeVar, Union, ) StateChangeID = NewType("StateChangeID", ULID) SnapshotID = NewType("SnapshotID", ULID) EventID = NewType("EventID", ULID) ID = TypeVar("ID", StateChangeID, SnapshotID, EventID) @dataclass class Range(Generic[ID]): """Inclusive range used to filter database entries.""" first: ID last: ID def __post_init__(self) -> None: # Because the range is inclusive, the values can be equal if self.first > self.last: raise ValueError("last must be larger or equal to first")
Range(from_identifier, state_change_identifier)) if unapplied_state_changes: log.debug( "Replaying state changes", replayed_state_changes=[ redact_secret(DictSerializer.serialize(state_change)) for state_change in unapplied_state_changes ], node=to_checksum_address(node_address), ) wal.state_manager.dispatch(unapplied_state_changes) return wal ST = TypeVar("ST", bound=State) @dataclass(frozen=True) class SavedState(Generic[ST]): """Saves the state and the id of the state change that produced it. This datastructure keeps the state and the state_change_id synchronized. Having these values available is useful for debugging. """ state_change_id: StateChangeID state: ST class WriteAheadLog(Generic[ST]):
Set, Tuple, List, Optional, Address, Callable, Mapping, TypeVar, Union, Type, ) from raiden_libs.network.matrix import GMatrixClient, Room log = structlog.get_logger(__name__) _CT = TypeVar('CT') # class type _CIT = Union[_CT, Type[_CT]] # class or instance type _RT = TypeVar('RT') # return type _CacheT = Mapping[Tuple, _RT] # cache type (mapping) def _cachegetter( attr: str, cachefactory: Callable[ [], _CacheT] = WeakKeyDictionary, # WeakKewDict best for properties ) -> Callable[[_CIT], _CacheT]: """Returns a safer attrgetter which constructs the missing object with cachefactory May be used for normal methods, classmethods and properties, as default factory is a WeakKeyDictionary (good for storing weak-refs for self or cls).
Dict, Keccak256, List, Locksroot, Secret, SecretHash, TransactionHash, Tuple, TypeVar, ) # The names `T`, `KT`, `VT` are used the same way as the documentation: # https://mypy.readthedocs.io/en/latest/generics.html#defining-sub-classes-of-generic-classes # R stands for return type T = TypeVar("T") # function type RT = TypeVar("RT") # function return type KT = TypeVar("KT") # dict key type VT = TypeVar("VT") # dict value type KRT = TypeVar("KRT") # dict key return type VRT = TypeVar("VRT") # dict value return type def identity(val: T) -> T: return val def map_dict(key_func: Callable[[KT], KRT], value_func: Callable[[VT], VRT], dict_: Dict[KT, VT]) -> Dict[KRT, VRT]: return {key_func(k): value_func(v) for k, v in dict_.items()}
assert all(isinstance(e, Event) for e in events) return events def __eq__(self, other): return ( isinstance(other, StateManager) and self.state_transition == other.state_transition and self.current_state == other.current_state ) def __ne__(self, other): return not self.__eq__(other) ST = TypeVar('ST', bound=State) class TransitionResult(Generic[ST]): # pylint: disable=unsubscriptable-object """ Representes the result of applying a single state change. When a task is completed the new_state is set to None, allowing the parent task to cleanup after the child. """ __slots__ = ( 'new_state', 'events', ) def __init__(self, new_state: ST, events: List[Event]):
if unapplied_state_changes: log.debug( "Replaying state changes", replayed_state_changes=[ redact_secret(DictSerializer.serialize(state_change)) for state_change in unapplied_state_changes ], node=to_checksum_address(node_address), ) for state_change in unapplied_state_changes: wal.state_manager.dispatch(state_change) return state_change_qty, len(unapplied_state_changes), wal ST = TypeVar("ST", bound=State) ST2 = TypeVar("ST2", bound=State) @dataclass(frozen=True) class SavedState(Generic[ST]): """Saves the state and the id of the state change that produced it. This datastructure keeps the state and the state_change_id synchronized. Having these values available is useful for debugging. """ state_change_id: StateChangeID state: ST
@dataclass(frozen=True) class ContractReceiveStateChange(StateChange): """ Marker used for state changes which represent on-chain logs. """ transaction_hash: TransactionHash block_number: BlockNumber block_hash: BlockHash def __post_init__(self) -> None: typecheck(self.block_number, T_BlockNumber) typecheck(self.block_hash, T_BlockHash) T = TypeVar("T", covariant=True) ST = TypeVar("ST", bound=State) class TransitionResult(Generic[T]): # pylint: disable=unsubscriptable-object """ Representes the result of applying a single state change. When a task is completed the new_state is set to None, allowing the parent task to cleanup after the child. """ def __init__(self, new_state: T, events: List[Event]) -> None: self.new_state = new_state self.events = events def __eq__(self, other: Any) -> bool:
from dataclasses import dataclass from raiden.utils.typing import ( ABI, Address, BlockNumber, EVMBytecode, GasMeasurements, Optional, TypeVar, ) T = TypeVar("T") @dataclass class SmartContractMetadata: """Basic metadata of a smart contract.""" # If the user deployed the smart contract, the mined block is unknown. deployed_at: Optional[BlockNumber] # Value to use as `fromBlock` for filters. If the deployed block number is # know it must be used, otherwise a hard fork block number can be used as a # lower bound. # # The deployed_at must be used because querying for logs before the smart # contract is deployed has bad performance (see #3958), and values larger # than the deployed_at will potentially miss logs. filters_start_at: BlockNumber
assert len(self.identifier) == 16, "id_ must be 16 bytes long" def __repr__(self) -> str: return f"ULID<{self.identifier.hex()}>" @property def timestamp(self) -> int: """Aproximated timestamp of the database entry. There is no lower bound for the skew in time. """ timestamp_bytes = self.identifier[:8] return int.from_bytes(timestamp_bytes, "big") ID = TypeVar("ID", bound=ULID) class ULIDMonotonicFactory(Generic[ID]): """Monotonic ULID factory that guarantees new ULIDs will not decrease. This factory does not follow the SPEC. The timestamp is not walltime and the precision was increased from ms to ns to guarantee total order. time.time() can not be used because it is not monotonic. The clock can be reset by the user, a NTPD daemon, adjusted because of TZ changes, adjusted because of leap seconds, etc. Therefore a monotonic clock must be used. """ def __init__(self, start: Optional[int]) -> None: resolution = clock_getres(CLOCK_MONOTONIC_RAW)
from collections.abc import Mapping import gevent from raiden.raiden_service import RaidenService from raiden.storage.sqlite import RANGE_ALL_STATE_CHANGES from raiden.transfer.architecture import Event, StateChange from raiden.transfer.mediated_transfer.events import EventUnlockClaimFailed, EventUnlockFailed from raiden.utils.typing import Any, Iterable, List, Optional, Tuple, Type, TypeVar NOVALUE = object() T = TypeVar("T") SC = TypeVar("SC", bound=StateChange) TM = TypeVar("TM", bound=Mapping) def check_dict_nested_attrs(item: Mapping, dict_data: Mapping) -> bool: """ Checks the values from `dict_data` are contained in `item` >>> d = {'a': 1, 'b': {'c': 2}} >>> check_dict_nested_attrs(d, {'a': 1}) True >>> check_dict_nested_attrs(d, {'b': {'c': 2}}) True >>> check_dict_nested_attrs(d, {'d': []}) False """ for key, value in dict_data.items(): if key not in item: return False
Dict, Keccak256, List, Locksroot, Secret, SecretHash, TransactionHash, Tuple, TypeVar, ) # The names `T`, `KT`, `VT` are used the same way as the documentation: # https://mypy.readthedocs.io/en/latest/generics.html#defining-sub-classes-of-generic-classes # R stands for return type T = TypeVar('T') # function type RT = TypeVar('RT') # function return type KT = TypeVar('KT') # dict key type VT = TypeVar('VT') # dict value type KRT = TypeVar('KRT') # dict key return type VRT = TypeVar('VRT') # dict value return type def identity(val: T) -> T: return val def map_dict( key_func: Callable[[KT], KRT], value_func: Callable[[VT], VRT], dict_: Dict[KT, VT],