whoami7 - Manager
:
/
proc
/
self
/
root
/
opt
/
hc_python
/
lib64
/
python3.8
/
site-packages
/
sqlalchemy
/
orm
/
Upload File:
files >> //proc/self/root/opt/hc_python/lib64/python3.8/site-packages/sqlalchemy/orm/identity.py
# orm/identity.py # Copyright (C) 2005-2024 the SQLAlchemy authors and contributors # <see AUTHORS file> # # This module is part of SQLAlchemy and is released under # the MIT License: https://www.opensource.org/licenses/mit-license.php from __future__ import annotations from typing import Any from typing import cast from typing import Dict from typing import Iterable from typing import Iterator from typing import List from typing import NoReturn from typing import Optional from typing import Set from typing import Tuple from typing import TYPE_CHECKING from typing import TypeVar import weakref from . import util as orm_util from .. import exc as sa_exc if TYPE_CHECKING: from ._typing import _IdentityKeyType from .state import InstanceState _T = TypeVar("_T", bound=Any) _O = TypeVar("_O", bound=object) class IdentityMap: _wr: weakref.ref[IdentityMap] _dict: Dict[_IdentityKeyType[Any], Any] _modified: Set[InstanceState[Any]] def __init__(self) -> None: self._dict = {} self._modified = set() self._wr = weakref.ref(self) def _kill(self) -> None: self._add_unpresent = _killed # type: ignore def all_states(self) -> List[InstanceState[Any]]: raise NotImplementedError() def contains_state(self, state: InstanceState[Any]) -> bool: raise NotImplementedError() def __contains__(self, key: _IdentityKeyType[Any]) -> bool: raise NotImplementedError() def safe_discard(self, state: InstanceState[Any]) -> None: raise NotImplementedError() def __getitem__(self, key: _IdentityKeyType[_O]) -> _O: raise NotImplementedError() def get( self, key: _IdentityKeyType[_O], default: Optional[_O] = None ) -> Optional[_O]: raise NotImplementedError() def fast_get_state( self, key: _IdentityKeyType[_O] ) -> Optional[InstanceState[_O]]: raise NotImplementedError() def keys(self) -> Iterable[_IdentityKeyType[Any]]: return self._dict.keys() def values(self) -> Iterable[object]: raise NotImplementedError() def replace(self, state: InstanceState[_O]) -> Optional[InstanceState[_O]]: raise NotImplementedError() def add(self, state: InstanceState[Any]) -> bool: raise NotImplementedError() def _fast_discard(self, state: InstanceState[Any]) -> None: raise NotImplementedError() def _add_unpresent( self, state: InstanceState[Any], key: _IdentityKeyType[Any] ) -> None: """optional inlined form of add() which can assume item isn't present in the map""" self.add(state) def _manage_incoming_state(self, state: InstanceState[Any]) -> None: state._instance_dict = self._wr if state.modified: self._modified.add(state) def _manage_removed_state(self, state: InstanceState[Any]) -> None: del state._instance_dict if state.modified: self._modified.discard(state) def _dirty_states(self) -> Set[InstanceState[Any]]: return self._modified def check_modified(self) -> bool: """return True if any InstanceStates present have been marked as 'modified'. """ return bool(self._modified) def has_key(self, key: _IdentityKeyType[Any]) -> bool: return key in self def __len__(self) -> int: return len(self._dict) class WeakInstanceDict(IdentityMap): _dict: Dict[_IdentityKeyType[Any], InstanceState[Any]] def __getitem__(self, key: _IdentityKeyType[_O]) -> _O: state = cast("InstanceState[_O]", self._dict[key]) o = state.obj() if o is None: raise KeyError(key) return o def __contains__(self, key: _IdentityKeyType[Any]) -> bool: try: if key in self._dict: state = self._dict[key] o = state.obj() else: return False except KeyError: return False else: return o is not None def contains_state(self, state: InstanceState[Any]) -> bool: if state.key in self._dict: if TYPE_CHECKING: assert state.key is not None try: return self._dict[state.key] is state except KeyError: return False else: return False def replace( self, state: InstanceState[Any] ) -> Optional[InstanceState[Any]]: assert state.key is not None if state.key in self._dict: try: existing = existing_non_none = self._dict[state.key] except KeyError: # catch gc removed the key after we just checked for it existing = None else: if existing_non_none is not state: self._manage_removed_state(existing_non_none) else: return None else: existing = None self._dict[state.key] = state self._manage_incoming_state(state) return existing def add(self, state: InstanceState[Any]) -> bool: key = state.key assert key is not None # inline of self.__contains__ if key in self._dict: try: existing_state = self._dict[key] except KeyError: # catch gc removed the key after we just checked for it pass else: if existing_state is not state: o = existing_state.obj() if o is not None: raise sa_exc.InvalidRequestError( "Can't attach instance " "%s; another instance with key %s is already " "present in this session." % (orm_util.state_str(state), state.key) ) else: return False self._dict[key] = state self._manage_incoming_state(state) return True def _add_unpresent( self, state: InstanceState[Any], key: _IdentityKeyType[Any] ) -> None: # inlined form of add() called by loading.py self._dict[key] = state state._instance_dict = self._wr def fast_get_state( self, key: _IdentityKeyType[_O] ) -> Optional[InstanceState[_O]]: return self._dict.get(key) def get( self, key: _IdentityKeyType[_O], default: Optional[_O] = None ) -> Optional[_O]: if key not in self._dict: return default try: state = cast("InstanceState[_O]", self._dict[key]) except KeyError: # catch gc removed the key after we just checked for it return default else: o = state.obj() if o is None: return default return o def items(self) -> List[Tuple[_IdentityKeyType[Any], InstanceState[Any]]]: values = self.all_states() result = [] for state in values: value = state.obj() key = state.key assert key is not None if value is not None: result.append((key, value)) return result def values(self) -> List[object]: values = self.all_states() result = [] for state in values: value = state.obj() if value is not None: result.append(value) return result def __iter__(self) -> Iterator[_IdentityKeyType[Any]]: return iter(self.keys()) def all_states(self) -> List[InstanceState[Any]]: return list(self._dict.values()) def _fast_discard(self, state: InstanceState[Any]) -> None: # used by InstanceState for state being # GC'ed, inlines _managed_removed_state key = state.key assert key is not None try: st = self._dict[key] except KeyError: # catch gc removed the key after we just checked for it pass else: if st is state: self._dict.pop(key, None) def discard(self, state: InstanceState[Any]) -> None: self.safe_discard(state) def safe_discard(self, state: InstanceState[Any]) -> None: key = state.key if key in self._dict: assert key is not None try: st = self._dict[key] except KeyError: # catch gc removed the key after we just checked for it pass else: if st is state: self._dict.pop(key, None) self._manage_removed_state(state) def _killed(state: InstanceState[Any], key: _IdentityKeyType[Any]) -> NoReturn: # external function to avoid creating cycles when assigned to # the IdentityMap raise sa_exc.InvalidRequestError( "Object %s cannot be converted to 'persistent' state, as this " "identity map is no longer valid. Has the owning Session " "been closed?" % orm_util.state_str(state), code="lkrp", )
Copyright ©2021 || Defacer Indonesia