From 1f4c4c2cc70ea3dad6d82459604e2e71e13a27f1 Mon Sep 17 00:00:00 2001 From: "Alexie (Boyong) Madolid" Date: Wed, 11 Sep 2024 22:16:56 +0800 Subject: [PATCH] temporary --- jac/jaclang/runtimelib/memory.py | 83 +++++++++++++++----------------- 1 file changed, 40 insertions(+), 43 deletions(-) diff --git a/jac/jaclang/runtimelib/memory.py b/jac/jaclang/runtimelib/memory.py index 6986fff61d..2874053181 100644 --- a/jac/jaclang/runtimelib/memory.py +++ b/jac/jaclang/runtimelib/memory.py @@ -6,18 +6,19 @@ from pickle import dumps from shelve import Shelf, open from typing import Callable, Generator, Generic, Iterable, TypeVar +from uuid import UUID -from .implementation import EdgeAnchor, JID, NodeAnchor, WalkerAnchor, _ANCHOR +from .architype import Anchor, NodeAnchor, Root, TANCH ID = TypeVar("ID") @dataclass -class Memory(Generic[ID, _ANCHOR]): +class Memory(Generic[ID, TANCH]): """Generic Memory Handler.""" - __mem__: dict[ID, _ANCHOR] = field(default_factory=dict) - __gc__: set[_ANCHOR] = field(default_factory=set) + __mem__: dict[ID, TANCH] = field(default_factory=dict) + __gc__: set[TANCH] = field(default_factory=set) def close(self) -> None: """Close memory handler.""" @@ -27,8 +28,8 @@ def close(self) -> None: def find( self, ids: ID | Iterable[ID], - filter: Callable[[_ANCHOR], _ANCHOR] | None = None, - ) -> Generator[_ANCHOR, None, None]: + filter: Callable[[TANCH], TANCH] | None = None, + ) -> Generator[TANCH, None, None]: """Find anchors from memory by ids with filter.""" if not isinstance(ids, Iterable): ids = [ids] @@ -42,16 +43,16 @@ def find( def find_one( self, ids: ID | Iterable[ID], - filter: Callable[[_ANCHOR], _ANCHOR] | None = None, - ) -> _ANCHOR | None: + filter: Callable[[TANCH], TANCH] | None = None, + ) -> TANCH | None: """Find one anchor from memory by ids with filter.""" return next(self.find(ids, filter), None) - def find_by_id(self, id: ID) -> _ANCHOR | None: + def find_by_id(self, id: ID) -> TANCH | None: """Find one by id.""" return self.__mem__.get(id) - def set(self, id: ID, data: _ANCHOR) -> None: + def set(self, id: ID, data: TANCH) -> None: """Save anchor to memory.""" self.__mem__[id] = data @@ -66,10 +67,10 @@ def remove(self, ids: ID | Iterable[ID]) -> None: @dataclass -class ShelfStorage(Memory[JID, EdgeAnchor | NodeAnchor | WalkerAnchor]): +class ShelfStorage(Memory[UUID, Anchor]): """Shelf Handler.""" - __shelf__: Shelf[EdgeAnchor | NodeAnchor | WalkerAnchor] | None = None + __shelf__: Shelf[Anchor] | None = None def __init__(self, session: str | None = None) -> None: """Initialize memory handler.""" @@ -84,48 +85,44 @@ def close(self) -> None: root = Jac.get_root().__jac__ for anchor in self.__gc__: - self.__shelf__.pop(str(anchor.jid), None) - self.__mem__.pop(anchor.jid, None) + self.__shelf__.pop(str(anchor.id), None) + self.__mem__.pop(anchor.id, None) - for anchor in self.__mem__.values(): - if anchor.persistent and anchor.hash != hash(dumps(anchor)): - jid = str(anchor.jid) - if source_anchor := self.__shelf__.get(jid): + for d in self.__mem__.values(): + if d.persistent and d.hash != hash(dumps(d)): + _id = str(d.id) + if p_d := self.__shelf__.get(_id): if ( - isinstance(source_anchor, NodeAnchor) - and isinstance(anchor, NodeAnchor) - and source_anchor.edge_ids != anchor.edge_ids - and root.has_connect_access(anchor) + isinstance(p_d, NodeAnchor) + and isinstance(d, NodeAnchor) + and p_d.edges != d.edges + and root.has_connect_access(d) ): - if not anchor.edges: - self.__shelf__.pop(jid, None) + if not d.edges: + self.__shelf__.pop(_id, None) continue - source_anchor.edges = anchor.edges - - if root.has_write_access(anchor): - if hash(dumps(source_anchor.access)) != hash( - dumps(anchor.access) - ): - source_anchor.access = anchor.access - if hash(dumps(anchor.architype)) != hash( - dumps(anchor.architype) - ): - source_anchor.architype = anchor.architype - - self.__shelf__[jid] = source_anchor + p_d.edges = d.edges + + if root.has_write_access(d): + if hash(dumps(p_d.access)) != hash(dumps(d.access)): + p_d.access = d.access + if hash(dumps(d.architype)) != hash(dumps(d.architype)): + p_d.architype = d.architype + + self.__shelf__[_id] = p_d elif not ( - isinstance(anchor, NodeAnchor) - and not isinstance(anchor.architype, Root) - and not anchor.edges + isinstance(d, NodeAnchor) + and not isinstance(d.architype, Root) + and not d.edges ): - self.__shelf__[jid] = anchor + self.__shelf__[_id] = d self.__shelf__.close() super().close() def find( self, - ids: JID | Iterable[JID], + ids: UUID | Iterable[UUID], filter: Callable[[Anchor], Anchor] | None = None, ) -> Generator[Anchor, None, None]: """Find anchors from datasource by ids with filter.""" @@ -147,7 +144,7 @@ def find( else: yield from super().find(ids, filter) - def find_by_id(self, id: JID) -> Anchor | None: + def find_by_id(self, id: UUID) -> Anchor | None: """Find one by id.""" data = super().find_by_id(id)