60 lines
2.2 KiB
Python
60 lines
2.2 KiB
Python
from typing import Generic, Iterable, TypeVar
|
|
|
|
from rainbowadn.core import *
|
|
from .keyed import Keyed
|
|
|
|
__all__ = ('KeyMetadata', 'KeyMetadataFactory',)
|
|
|
|
ActiveKeyType = TypeVar('ActiveKeyType')
|
|
MetaDataType = TypeVar('MetaDataType')
|
|
|
|
|
|
class KeyMetadata(Keyed[ActiveKeyType], Generic[ActiveKeyType, MetaDataType]):
|
|
def __init__(self, key: HashPoint[ActiveKeyType], metadata: HashPoint[MetaDataType]):
|
|
assert isinstance(key, HashPoint)
|
|
assert isinstance(metadata, HashPoint)
|
|
super().__init__(key)
|
|
self.metadata = metadata
|
|
|
|
def points(self) -> Iterable[HashPoint]:
|
|
return [self.key, self.metadata]
|
|
|
|
def __bytes__(self):
|
|
return bytes(self.key) + bytes(self.metadata)
|
|
|
|
def __factory__(self) -> RainbowFactory['KeyMetadata[ActiveKeyType, MetaDataType]']:
|
|
return KeyMetadataFactory(self.key.factory, self.metadata.factory)
|
|
|
|
async def str(self, tab: int) -> str:
|
|
assert isinstance(tab, int)
|
|
key_str, metadata_str = await gather(
|
|
hash_point_format(self.key, tab),
|
|
hash_point_format(self.metadata, tab)
|
|
)
|
|
assert isinstance(key_str, str)
|
|
assert isinstance(metadata_str, str)
|
|
return f'{key_str}' \
|
|
f'{tabulate(tab)}{metadata_str}'
|
|
|
|
|
|
class KeyMetadataFactory(
|
|
RainbowFactory[KeyMetadata[ActiveKeyType, MetaDataType]],
|
|
Generic[ActiveKeyType, MetaDataType]
|
|
):
|
|
def __init__(self, key_factory: RainbowFactory[ActiveKeyType], metadata_factory: RainbowFactory[MetaDataType]):
|
|
assert isinstance(key_factory, RainbowFactory)
|
|
assert isinstance(metadata_factory, RainbowFactory)
|
|
self.key_factory = key_factory
|
|
self.metadata_factory = metadata_factory
|
|
|
|
def from_bytes(self, source: bytes, resolver: HashResolver) -> KeyMetadata[ActiveKeyType, MetaDataType]:
|
|
assert isinstance(source, bytes)
|
|
assert isinstance(resolver, HashResolver)
|
|
return KeyMetadata(
|
|
ResolverOrigin(self.key_factory, source[:HashPoint.HASH_LENGTH], resolver).hash_point(),
|
|
ResolverOrigin(self.metadata_factory, source[HashPoint.HASH_LENGTH:], resolver).hash_point(),
|
|
)
|
|
|
|
def loose(self) -> RainbowFactory[KeyMetadata[ActiveKeyType, MetaDataType]]:
|
|
return self
|