本文整理汇总了Python中weakref.WeakValueDictionary.clear方法的典型用法代码示例。如果您正苦于以下问题:Python WeakValueDictionary.clear方法的具体用法?Python WeakValueDictionary.clear怎么用?Python WeakValueDictionary.clear使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类weakref.WeakValueDictionary
的用法示例。
在下文中一共展示了WeakValueDictionary.clear方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: Signal
# 需要导入模块: from weakref import WeakValueDictionary [as 别名]
# 或者: from weakref.WeakValueDictionary import clear [as 别名]
class Signal(object):
"""
A Signal is callable. When called, it calls all the callables in its slots.
"""
def __init__(self):
self._slots = WeakValueDictionary()
def __call__(self, *args, **kargs):
for key in self._slots:
func, _ = key
func(self._slots[key], *args, **kargs)
def connect(self, slot):
"""
Slots must call this to register a callback method.
:param slot: callable
"""
key = (slot.im_func, id(slot.im_self))
self._slots[key] = slot.im_self
def disconnect(self, slot):
"""
They can also unregister their callbacks here.
:param slot: callable
"""
key = (slot.im_func, id(slot.im_self))
if key in self._slots:
self._slots.pop(key)
def clear(self):
"""
Clears all slots
"""
self._slots.clear()
示例2: Signal
# 需要导入模块: from weakref import WeakValueDictionary [as 别名]
# 或者: from weakref.WeakValueDictionary import clear [as 别名]
class Signal(object):
def __init__(self):
self.__slots = WeakValueDictionary()
def __call__(self, *args, **kargs):
for key in self.__slots:
func, selfid = key
if selfid is not None:
func(self.__slots[key], *args, **kargs)
else:
func(*args, **kargs)
def __get_key(self, slot):
if hasattr(slot, 'im_func'):
return (slot.im_func, id(slot.im_self))
else:
return (slot, None)
def connect(self, slot):
key = self.__get_key(slot)
if hasattr(slot, 'im_func'):
self.__slots[key] = slot.im_self
else:
self.__slots[key] = slot
def disconnect(self, slot):
key = self.__get_key(slot)
if key in self.__slots:
self.__slots.pop(key)
def clear(self):
self.__slots.clear()
示例3: ObjectPool
# 需要导入模块: from weakref import WeakValueDictionary [as 别名]
# 或者: from weakref.WeakValueDictionary import clear [as 别名]
class ObjectPool(object):
"""
This class allows to fetch mvc model objects using their UUID.
This requires to model to have a property called "uuid". All
class inheriting from the base 'Model' class will have this.
If implementing a custom model, the UUID property is responsible
for the removal and addition to the pool when it changes values.
Also see the UUIDPropIntel class for an example implementation.
We can use this to store complex relations between objects where
references to each other can be replaced with the UUID.
For a multi-threaded version see ThreadedObjectPool.
"""
def __init__(self, *args, **kwargs):
object.__init__(self)
self._objects = WeakValueDictionary()
def add_or_get_object(self, obj):
try:
self.add_object(obj, force=False, silent=False)
return obj
except KeyError:
return self.get_object(obj.uuid)
def add_object(self, obj, force=False, fail_on_duplicate=False):
if not obj.uuid in self._objects or force:
self._objects[obj.uuid] = obj
elif fail_on_duplicate:
raise KeyError, "UUID %s is already taken by another object %s, cannot add object %s" % (obj.uuid, self._objects[obj.uuid], obj)
else:
# Just change the objects uuid, will break refs, but
# it prevents issues with inherited properties etc.
logger.warning("A duplicate UUID was passed to an ObjectPool for a %s object." % obj)
obj.uuid = get_new_uuid()
def change_all_uuids(self):
# first get a copy off all uuids & objects:
items = self._objects.items()
for uuid, obj in items: # @UnusedVariable
obj.uuid = get_new_uuid()
def remove_object(self, obj):
if obj.uuid in self._objects and self._objects[obj.uuid] == obj:
del self._objects[obj.uuid]
def get_object(self, uuid):
obj = self._objects.get(uuid, None)
return obj
def clear(self):
self._objects.clear()
示例4: Signal
# 需要导入模块: from weakref import WeakValueDictionary [as 别名]
# 或者: from weakref.WeakValueDictionary import clear [as 别名]
class Signal(object):
def __init__(self):
self.__slots = WeakValueDictionary()
def __call__(self, *args, **kargs):
for key in self.__slots:
func, _ = key
func(self.__slots[key], *args, **kargs)
def connect(self, slot):
key = (slot.__func__, id(slot.__self__))
self.__slots[key] = slot.__self__
def disconnect(self, slot):
key = (slot.__func__, id(slot.__self__))
if key in self.__slots:
self.__slots.pop(key)
def clear(self):
self.__slots.clear()
示例5: ThreadLocalEntityCache
# 需要导入模块: from weakref import WeakValueDictionary [as 别名]
# 或者: from weakref.WeakValueDictionary import clear [as 别名]
class ThreadLocalEntityCache(local):
def __init__(self):
self.lock = Lock()
self._dict = WeakValueDictionary()
def __contains__(self, key):
return key in self._dict
def __getitem__(self, key):
return self._dict[key]
def clear(self):
self._dict.clear()
def update(self, key, value):
""" Extract, insert or remove a value for a given key.
"""
with self.lock:
if value is None:
# remove
try:
del self._dict[key]
except KeyError:
pass
else:
return None
elif callable(value):
try:
# extract
return self._dict[key]
except KeyError:
# construct and insert
new_value = value()
self._dict[key] = new_value
return new_value
else:
# insert or replace
self._dict[key] = value
return value
示例6: Signal
# 需要导入模块: from weakref import WeakValueDictionary [as 别名]
# 或者: from weakref.WeakValueDictionary import clear [as 别名]
class Signal(object):
"""
Signal slot object, used for handling events passed to the objects in the gui.
"""
def __init__(self):
self.__slots = WeakValueDictionary()
def __call__(self, *args, **kargs):
for key in self.__slots:
func, _ = key
func(self.__slots[key], *args, **kargs)
def connect(self, slot):
key = (slot.im_func, id(slot.im_self))
self.__slots[key] = slot.im_self
def disconnect(self, slot):
key = (slot.im_func, id(slot.im_self))
if key in self.__slots:
self.__slots.pop(key)
def clear(self):
self.__slots.clear()
示例7: Signal
# 需要导入模块: from weakref import WeakValueDictionary [as 别名]
# 或者: from weakref.WeakValueDictionary import clear [as 别名]
class Signal(object):
def __init__(self):
self.__slots = WeakValueDictionary()
# For keeping references to _FuncHost objects.
self.__funchosts = {}
def __call__(self, *args, **kargs):
for key in self.__slots:
func, _ = key
func(self.__slots[key], *args, **kargs)
def connect(self, slot):
if inspect.ismethod(slot):
key = (slot.im_func, id(slot.im_self))
self.__slots[key] = slot.im_self
else:
host = _FuncHost(slot)
self.connect(host.meth)
# We stick a copy in here just to keep the instance alive.
self.__funchosts[slot] = host
def disconnect(self, slot):
if inspect.ismethod(slot):
key = (slot.im_func, id(slot.im_self))
if key in self.__slots:
self.__slots.pop(key)
else:
if slot in self.__funchosts:
self.disconnect(self.__funchosts[slot].meth)
self.__funchosts.pop(slot)
def clear(self):
self.__slots.clear()
self.__funchosts.clear()
示例8: DispatchTree
# 需要导入模块: from weakref import WeakValueDictionary [as 别名]
# 或者: from weakref.WeakValueDictionary import clear [as 别名]
class DispatchTree(object):
def __init__(self):
# core data
self.root = FolderNode(0, "root", None, "root", 1, 1, 0, FifoStrategy())
self.nodes = WeakValueDictionary()
self.nodes[0] = self.root
self.pools = {}
self.renderNodes = {}
self.tasks = {}
self.rules = []
self.poolShares = {}
self.commands = {}
# deduced properties
self.nodeMaxId = 0
self.poolMaxId = 0
self.renderNodeMaxId = 0
self.taskMaxId = 0
self.commandMaxId = 0
self.poolShareMaxId = 0
self.toCreateElements = []
self.toModifyElements = []
self.toArchiveElements = []
# listeners
self.nodeListener = ObjectListener(self.onNodeCreation, self.onNodeDestruction, self.onNodeChange)
self.taskListener = ObjectListener(self.onTaskCreation, self.onTaskDestruction, self.onTaskChange)
# # JSA
# self.taskGroupListener = ObjectListener(self.onTaskCreation, self.onTaskDestruction, self.onTaskGroupChange)
self.renderNodeListener = ObjectListener(
self.onRenderNodeCreation, self.onRenderNodeDestruction, self.onRenderNodeChange
)
self.poolListener = ObjectListener(self.onPoolCreation, self.onPoolDestruction, self.onPoolChange)
self.commandListener = ObjectListener(
onCreationEvent=self.onCommandCreation, onChangeEvent=self.onCommandChange
)
self.poolShareListener = ObjectListener(self.onPoolShareCreation)
self.modifiedNodes = []
def registerModelListeners(self):
BaseNode.changeListeners.append(self.nodeListener)
Task.changeListeners.append(self.taskListener)
TaskGroup.changeListeners.append(self.taskListener)
RenderNode.changeListeners.append(self.renderNodeListener)
Pool.changeListeners.append(self.poolListener)
Command.changeListeners.append(self.commandListener)
PoolShare.changeListeners.append(self.poolShareListener)
def destroy(self):
BaseNode.changeListeners.remove(self.nodeListener)
Task.changeListeners.remove(self.taskListener)
RenderNode.changeListeners.remove(self.renderNodeListener)
Pool.changeListeners.remove(self.poolListener)
Command.changeListeners.remove(self.commandListener)
PoolShare.changeListeners.remove(self.poolShareListener)
self.root = None
self.nodes.clear()
self.pools.clear()
self.renderNodes.clear()
self.tasks.clear()
self.rules = None
self.commands.clear()
self.poolShares = None
self.modifiedNodes = None
self.toCreateElements = None
self.toModifyElements = None
self.toArchiveElements = None
def findNodeByPath(self, path, default=None):
nodenames = splitpath(path)
node = self.root
for name in nodenames:
for child in node.children:
if child.name == name:
node = child
break
else:
return default
return node
def updateCompletionAndStatus(self):
self.root.updateCompletionAndStatus()
def validateDependencies(self):
nodes = set()
for dependency in self.modifiedNodes:
for node in dependency.reverseDependencies:
nodes.add(node)
del self.modifiedNodes[:]
for node in nodes:
# logger.debug("Dependencies on %r = %r"% (node.name, node.checkDependenciesSatisfaction() ) )
if not hasattr(node, "task") or node.task is None:
continue
if isinstance(node, TaskNode):
if node.checkDependenciesSatisfaction():
for cmd in node.task.commands:
if cmd.status == CMD_BLOCKED:
cmd.status = CMD_READY
else:
for cmd in node.task.commands:
if cmd.status == CMD_READY:
cmd.status = CMD_BLOCKED
#.........这里部分代码省略.........
示例9: TaskQueue
# 需要导入模块: from weakref import WeakValueDictionary [as 别名]
# 或者: from weakref.WeakValueDictionary import clear [as 别名]
class TaskQueue(AbstractTaskQueue):
"""Simple in-memory task queue implementation"""
@classmethod
def factory(cls, url, name=const.DEFAULT, *args, **kw):
obj = _REFS.get((url, name))
if obj is None:
obj = _REFS[(url, name)] = cls(url, name, *args, **kw)
return obj
def __init__(self, *args, **kw):
super(TaskQueue, self).__init__(*args, **kw)
self.queue = Queue()
self.results = WeakValueDictionary()
self.results_lock = Lock()
def _init_result(self, result, status, message):
with self.results_lock:
if result.id in self.results:
return False
self.results[result.id] = result
result.__status = status
result.__value = Queue()
result.__task = message
result.__args = {}
result.__lock = Lock()
result.__for = None
return True
def enqueue_task(self, result, message):
if self._init_result(result, const.ENQUEUED, message):
self.queue.put(result)
return True
return False
def defer_task(self, result, message, args):
if self._init_result(result, const.PENDING, message):
results = self.results
# keep references to results to prevent GC
result.__refs = [results.get(arg) for arg in args]
return True
return False
def undefer_task(self, task_id):
result = self.results[task_id]
self.queue.put(result)
def get(self, timeout=None):
try:
result = self.queue.get(timeout=timeout)
except Empty:
return None
result.__status = const.PROCESSING
return result.id, result.__task
def size(self):
return len(self.results)
def discard_pending(self):
with self.results_lock:
while True:
try:
self.queue.get_nowait()
except Empty:
break
self.results.clear()
def reserve_argument(self, argument_id, deferred_id):
result = self.results.get(argument_id)
if result is None:
return (False, None)
with result.__lock:
if result.__for is not None:
return (False, None)
result.__for = deferred_id
try:
message = result.__value.get_nowait()
except Empty:
message = None
if message is not None:
with self.results_lock:
self.results.pop(argument_id, None)
return (True, message)
def set_argument(self, task_id, argument_id, message):
result = self.results[task_id]
with self.results_lock:
self.results.pop(argument_id, None)
with result.__lock:
result.__args[argument_id] = message
return len(result.__args) == len(result.__refs)
def get_arguments(self, task_id):
try:
return self.results[task_id].__args
except KeyError:
return {}
def set_task_timeout(self, task_id, timeout):
pass
#.........这里部分代码省略.........
示例10: clear
# 需要导入模块: from weakref import WeakValueDictionary [as 别名]
# 或者: from weakref.WeakValueDictionary import clear [as 别名]
def clear(self):
self.queue.clear()
return WeakValueDictionary.clear(self)
示例11: DispatchTree
# 需要导入模块: from weakref import WeakValueDictionary [as 别名]
# 或者: from weakref.WeakValueDictionary import clear [as 别名]
class DispatchTree(object):
def __init__(self):
# core data
self.root = FolderNode(0, "root", None, "root", 1, 1, 0, FifoStrategy())
self.nodes = WeakValueDictionary()
self.nodes[0] = self.root
self.pools = {}
self.renderNodes = {}
self.tasks = {}
self.rules = []
self.poolShares = {}
self.commands = {}
# deduced properties
self.nodeMaxId = 0
self.poolMaxId = 0
self.renderNodeMaxId = 0
self.taskMaxId = 0
self.commandMaxId = 0
self.poolShareMaxId = 0
self.toCreateElements = []
self.toModifyElements = []
self.toArchiveElements = []
# listeners
self.nodeListener = ObjectListener(self.onNodeCreation, self.onNodeDestruction, self.onNodeChange)
self.taskListener = ObjectListener(self.onTaskCreation, self.onTaskDestruction, self.onTaskChange)
self.renderNodeListener = ObjectListener(self.onRenderNodeCreation, self.onRenderNodeDestruction, self.onRenderNodeChange)
self.poolListener = ObjectListener(self.onPoolCreation, self.onPoolDestruction, self.onPoolChange)
self.commandListener = ObjectListener(onCreationEvent=self.onCommandCreation, onChangeEvent=self.onCommandChange)
self.poolShareListener = ObjectListener(self.onPoolShareCreation)
self.modifiedNodes = []
def registerModelListeners(self):
BaseNode.changeListeners.append(self.nodeListener)
Task.changeListeners.append(self.taskListener)
TaskGroup.changeListeners.append(self.taskListener)
RenderNode.changeListeners.append(self.renderNodeListener)
Pool.changeListeners.append(self.poolListener)
Command.changeListeners.append(self.commandListener)
PoolShare.changeListeners.append(self.poolShareListener)
def destroy(self):
BaseNode.changeListeners.remove(self.nodeListener)
Task.changeListeners.remove(self.taskListener)
RenderNode.changeListeners.remove(self.renderNodeListener)
Pool.changeListeners.remove(self.poolListener)
Command.changeListeners.remove(self.commandListener)
PoolShare.changeListeners.remove(self.poolShareListener)
self.root = None
self.nodes.clear()
self.pools.clear()
self.renderNodes.clear()
self.tasks.clear()
self.rules = None
self.commands.clear()
self.poolShares = None
self.modifiedNodes = None
self.toCreateElements = None
self.toModifyElements = None
self.toArchiveElements = None
def findNodeByPath(self, path, default=None):
nodenames = splitpath(path)
node = self.root
for name in nodenames:
for child in node.children:
if child.name == name:
node = child
break
else:
return default
return node
def updateCompletionAndStatus(self):
self.root.updateCompletionAndStatus()
def validateDependencies(self):
nodes = set()
for dependency in self.modifiedNodes:
for node in dependency.reverseDependencies:
nodes.add(node)
del self.modifiedNodes[:]
for node in nodes:
if isinstance(node, TaskNode):
if node.checkDependenciesSatisfaction():
for cmd in node.task.commands:
if cmd.status == CMD_BLOCKED:
cmd.status = CMD_READY
else:
for cmd in node.task.commands:
if cmd.status == CMD_READY:
cmd.status = CMD_BLOCKED
def registerNewGraph(self, graph):
user = graph['user']
taskDefs = graph['tasks']
poolName = graph['poolName']
if 'maxRN' in graph.items():
maxRN = int(graph['maxRN'])
else:
#.........这里部分代码省略.........
示例12: clear
# 需要导入模块: from weakref import WeakValueDictionary [as 别名]
# 或者: from weakref.WeakValueDictionary import clear [as 别名]
def clear(self):
self._head = self._tail = None
self._keepDict.clear()
WeakValueDictionary.clear(self)
示例13: Signal
# 需要导入模块: from weakref import WeakValueDictionary [as 别名]
# 或者: from weakref.WeakValueDictionary import clear [as 别名]
class Signal(object):
def __init__(self):
self.__slots = WeakValueDictionary()
def __call__(self, *args, **kargs):
for key in self.__slots:
func, _ = key
func(self.__slots[key], *args, **kargs)
def connect(self, slot):
if PYTHON3:
key = (slot.__func__, id(slot.__self__))
self.__slots[key] = slot.__self__
else:
key = (slot.im_func, id(slot.im_self))
self.__slots[key] = slot.im_self
def disconnect(self, slot):
if PYTHON3:
key = (slot.__func__, id(slot.__self__))
if key in self.__slots:
self.__slots.pop(key)
else:
key = (slot.im_func, id(slot.im_self))
if key in self.__slots:
self.__slots.pop(key)
def clear(self):
self.__slots.clear()
## Sample usage:
#class Model(object):
# def __init__(self, value):
# self.__value = value
# self.changed = Signal()
#
# def set_value(self, value):
# self.__value = value
# self.changed() # Emit signal
#
# def get_value(self):
# return self.__value
#
#
#class View(object):
# def __init__(self, model):
# self.model = model
# model.changed.connect(self.model_changed)
#
# def model_changed(self):
# print "New value:", self.model.get_value()
#
#
#model = Model(10)
#view1 = View(model)
#view2 = View(model)
#view3 = View(model)
#
#model.set_value(20)
#
#del view1
#model.set_value(30)
#
#model.changed.clear()
#model.set_value(40)
### end of http://code.activestate.com/recipes/576477/ }}}
示例14: Signal
# 需要导入模块: from weakref import WeakValueDictionary [as 别名]
# 或者: from weakref.WeakValueDictionary import clear [as 别名]
class Signal(object):
def __init__(self, *args):
self.__slots = WeakValueDictionary()
for slot in args:
self.connect(slot)
def __call__(self, slot, *args, **kwargs):
"""
Emit signal. If slot passed signal will be called only for this
slot, for all connected slots otherwise.
Calling this method directly lead to immediate signal processing.
It may be not thread-safe. Use emit method from this module for
delayed calling of signals.
"""
if slot is not None:
slots = (self.__slots[self.key(slot)],)
else:
slots = self.__slots.values()
for func in slots:
func(*args, **kwargs)
def key(self, slot):
"""
Get local key name for slot.
"""
if type(slot) == types.FunctionType:
key = (slot.__module__, slot.__name__)
elif type(slot) == types.MethodType:
key = (slot.__func__, id(slot.__self__))
elif isinstance(slot, basestring):
if not slot in registred_slots.keys():
raise ValueError('Slot {0} does not exists.'.format(slot))
key = slot
else:
raise ValueError('Slot {0} has non-slot type'.format(slot))
return key
def connect(self, slot):
"""
Connect signal to slot. Slot may be function, instance method
or name of function perviously registred by `slot` decorator.
"""
key = self.key(slot)
if type(slot) == types.FunctionType:
self.__slots[key] = slot
elif type(slot) == types.MethodType:
self.__slots[key] = partial(slot.__func__, slot.__self__)
elif isinstance(slot, basestring):
self.__slots[key] = registred_slots[slot]
def disconnect(self, slot):
"""
Remove slot from signal connetions.
"""
key = self.key(slot)
del self.__slots[key]
def clear(self):
"""
Disconnect all slots from signal.
"""
self.__slots.clear()
示例15: __init__
# 需要导入模块: from weakref import WeakValueDictionary [as 别名]
# 或者: from weakref.WeakValueDictionary import clear [as 别名]
#.........这里部分代码省略.........
return self.__fingerprint
def updateCache(self, data, fingerprint):
"""
Updates on-disk and memory caches.
Positional arguments:
data -- dictionary with data to update
fingerprint -- string with fingerprint
"""
# Make light version of data and add fingerprint
# to it
data = self.__stripData(data)
data['fingerprint'] = fingerprint
# Update disk cache
os.makedirs(os.path.dirname(self._diskCacheFile), mode=0o755, exist_ok=True)
with bz2.BZ2File(self._diskCacheFile, 'w') as file:
jsonData = json.dumps(data)
file.write(jsonData.encode('utf-8'))
# Update data cache; encode to JSON and decode back
# to make sure form of data is the same as after
# loading it from cache
data = json.loads(jsonData)
self.__updateMemCache(data)
def __stripData(self, data):
"""
Rework passed data, stripping dictionary
keys from it to reduce space needed to store it.
"""
slimData = {}
slimTypes = {}
for typeRow in data['types']:
typeId = typeRow['typeId']
slimTypes[typeId] = (typeRow['groupId'],
typeRow['categoryId'],
typeRow['durationAttributeId'],
typeRow['dischargeAttributeId'],
typeRow['rangeAttributeId'],
typeRow['falloffAttributeId'],
typeRow['trackingSpeedAttributeId'],
typeRow['fittableNonSingleton'],
tuple(typeRow['effects']), # List -> tuple
tuple(typeRow['attributes'].items())) # Dictionary -> tuple
slimData['types'] = slimTypes
slimAttribs = {}
for attrRow in data['attributes']:
attrId = attrRow['attributeId']
slimAttribs[attrId] = (attrRow['maxAttributeId'],
attrRow['defaultValue'],
attrRow['highIsGood'],
attrRow['stackable'])
slimData['attributes'] = slimAttribs
slimEffects = {}
for effectRow in data['effects']:
effectId = effectRow['effectId']
slimEffects[effectId] = (effectRow['effectCategory'],
effectRow['isOffensive'],
effectRow['isAssistance'],
effectRow['fittingUsageChanceAttributeId'],
effectRow['buildStatus'],
tuple(effectRow['modifiers'])) # List -> tuple
slimData['effects'] = slimEffects
slimModifiers = {}
for modifierRow in data['modifiers']:
modifierId = modifierRow['modifierId']
slimModifiers[modifierId] = (modifierRow['state'],
modifierRow['context'],
modifierRow['sourceAttributeId'],
modifierRow['operator'],
modifierRow['targetAttributeId'],
modifierRow['location'],
modifierRow['filterType'],
modifierRow['filterValue'])
slimData['modifiers'] = slimModifiers
return slimData
def __updateMemCache(self, data):
"""
Loads data into memory data cache.
Positional arguments:
data -- dictionary with data to load
"""
self.__typeDataCache = data['types']
self.__attributeDataCache = data['attributes']
self.__effectDataCache = data['effects']
self.__modifierDataCache = data['modifiers']
self.__fingerprint = data['fingerprint']
# Also clear object cache to make sure objects composed
# from old data are gone
self.__typeObjCache.clear()
self.__attributeObjCache.clear()
self.__effectObjCache.clear()
self.__modifierObjCache.clear()