本文整理汇总了Python中weakref.WeakSet.discard方法的典型用法代码示例。如果您正苦于以下问题:Python WeakSet.discard方法的具体用法?Python WeakSet.discard怎么用?Python WeakSet.discard使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类weakref.WeakSet
的用法示例。
在下文中一共展示了WeakSet.discard方法的13个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: LazyInvalidation
# 需要导入模块: from weakref import WeakSet [as 别名]
# 或者: from weakref.WeakSet import discard [as 别名]
class LazyInvalidation(object):
def __enter__(self):
assert threading.current_thread() == MAIN_THREAD
assert not evaluation_stack
self._watchMap = WeakKeyDictionary()
self._watchable_objects = WeakSet()
global invalidation_strategy
invalidation_strategy._invalidate_all()
invalidation_strategy = self
def _watch_object(self, object):
if object.watcher is not None and object.watcher not in self._watchMap:
self._watchMap[object.watcher] = WeakWatchIntermediary(object, object.watcher)
def _add_dependency(self, object):
if evaluation_stack:
evaluation_stack[-1].deps.append(object)
def _unwatch_object(self, object):
object.invalidate()
self._watchable_objects.discard(object)
def __exit__(self, type, value, traceback):
global invalidation_strategy
invalidation_strategy = LazyConstants()
for intermediary in self._watchMap.itervalues():
intermediary.release()
self._watchMap.clear()
def _invalidate_all(self):
raise TypeError('Cannot nest lazy_invalidation contexts')
示例2: Signal
# 需要导入模块: from weakref import WeakSet [as 别名]
# 或者: from weakref.WeakSet import discard [as 别名]
class Signal(object):
def __init__(self):
self._functions = WeakSet()
self._methods = WeakKeyDictionary()
def __call__(self, *args, **kargs):
# Call handler functions
to_be_removed = []
for func in self._functions.copy():
try:
func(*args, **kargs)
except RuntimeError:
Warning.warn('Signals func->RuntimeError: func "{}" will be removed.'.format(func))
to_be_removed.append(func)
for remove in to_be_removed:
self._functions.discard(remove)
# Call handler methods
to_be_removed = []
emitters = self._methods.copy()
for obj, funcs in emitters.items():
msg_debug('obj is type "{}"'.format(type(obj)))
for func in funcs.copy():
try:
func(obj, *args, **kargs)
except RuntimeError:
warnings.warn('Signals methods->RuntimeError, obj.func "{}.{}" will be removed'.format(obj, func))
to_be_removed.append((obj, func))
for obj, func in to_be_removed:
self._methods[obj].discard(func)
def connect(self, slot):
if inspect.ismethod(slot):
if slot.__self__ not in self._methods:
self._methods[slot.__self__] = set()
self._methods[slot.__self__].add(slot.__func__)
else:
self._functions.add(slot)
def disconnect(self, slot):
if inspect.ismethod(slot):
if slot.__self__ in self._methods:
self._methods[slot.__self__].remove(slot.__func__)
else:
if slot in self._functions:
self._functions.remove(slot)
def clear(self):
self._functions.clear()
self._methods.clear()
示例3: ObservableEvent
# 需要导入模块: from weakref import WeakSet [as 别名]
# 或者: from weakref.WeakSet import discard [as 别名]
class ObservableEvent(object):
def __init__(self, weakref=False):
self.listeners = WeakSet() if weakref else set()
def __iadd__(self, ob):
self.listeners.add(ob)
return self
def __isub__(self, ob):
self.listeners.discard(ob)
return self
def notify(self, *a, **k):
for ob in list(self.listeners):
ob(*a, **k)
示例4: TestWeakSet
# 需要导入模块: from weakref import WeakSet [as 别名]
# 或者: from weakref.WeakSet import discard [as 别名]
#.........这里部分代码省略.........
self.assertFalse(set('cbs').issuperset('a'))
def test_lt(self):
self.assertTrue(self.ab_weakset < self.abcde_weakset)
self.assertFalse(self.abcde_weakset < self.def_weakset)
self.assertFalse(self.ab_weakset < self.ab_weakset)
self.assertFalse(WeakSet() < WeakSet())
def test_gt(self):
self.assertTrue(self.abcde_weakset > self.ab_weakset)
self.assertFalse(self.abcde_weakset > self.def_weakset)
self.assertFalse(self.ab_weakset > self.ab_weakset)
self.assertFalse(WeakSet() > WeakSet())
def test_gc(self):
# Create a nest of cycles to exercise overall ref count check
s = WeakSet(Foo() for i in range(1000))
for elem in s:
elem.cycle = s
elem.sub = elem
elem.set = WeakSet([elem])
def test_subclass_with_custom_hash(self):
# Bug #1257731
class H(WeakSet):
def __hash__(self):
return int(id(self) & 0x7fffffff)
s=H()
f=set()
f.add(s)
self.assertIn(s, f)
f.remove(s)
f.add(s)
f.discard(s)
def test_init(self):
s = WeakSet()
s.__init__(self.items)
self.assertEqual(s, self.s)
s.__init__(self.items2)
self.assertEqual(s, WeakSet(self.items2))
self.assertRaises(TypeError, s.__init__, s, 2);
self.assertRaises(TypeError, s.__init__, 1);
def test_constructor_identity(self):
s = WeakSet(self.items)
t = WeakSet(s)
self.assertNotEqual(id(s), id(t))
def test_hash(self):
self.assertRaises(TypeError, hash, self.s)
def test_clear(self):
self.s.clear()
self.assertEqual(self.s, WeakSet([]))
self.assertEqual(len(self.s), 0)
def test_copy(self):
dup = self.s.copy()
self.assertEqual(self.s, dup)
self.assertNotEqual(id(self.s), id(dup))
def test_add(self):
x = SomeClass('Q')
self.s.add(x)
self.assertIn(x, self.s)
示例5: AsyncoreLoop
# 需要导入模块: from weakref import WeakSet [as 别名]
# 或者: from weakref.WeakSet import discard [as 别名]
class AsyncoreLoop(object):
def __init__(self):
self._pid = os.getpid()
self._loop_lock = Lock()
self._started = False
self._shutdown = False
self._conns_lock = Lock()
self._conns = WeakSet()
self._thread = None
atexit.register(partial(_cleanup, weakref.ref(self)))
def maybe_start(self):
should_start = False
did_acquire = False
try:
did_acquire = self._loop_lock.acquire(False)
if did_acquire and not self._started:
self._started = True
should_start = True
finally:
if did_acquire:
self._loop_lock.release()
if should_start:
self._thread = Thread(target=self._run_loop, name="cassandra_driver_event_loop")
self._thread.daemon = True
self._thread.start()
def _run_loop(self):
log.debug("Starting asyncore event loop")
with self._loop_lock:
while True:
try:
asyncore.loop(timeout=0.001, use_poll=True, count=1000)
except Exception:
log.debug("Asyncore event loop stopped unexepectedly", exc_info=True)
break
if self._shutdown:
break
with self._conns_lock:
if len(self._conns) == 0:
break
self._started = False
log.debug("Asyncore event loop ended")
def _cleanup(self):
self._shutdown = True
if not self._thread:
return
log.debug("Waiting for event loop thread to join...")
self._thread.join(timeout=1.0)
if self._thread.is_alive():
log.warning(
"Event loop thread could not be joined, so shutdown may not be clean. "
"Please call Cluster.shutdown() to avoid this.")
log.debug("Event loop thread was joined")
def connection_created(self, connection):
with self._conns_lock:
self._conns.add(connection)
def connection_destroyed(self, connection):
with self._conns_lock:
self._conns.discard(connection)
示例6: TestWeakSet
# 需要导入模块: from weakref import WeakSet [as 别名]
# 或者: from weakref.WeakSet import discard [as 别名]
#.........这里部分代码省略.........
self.assertTrue(p < q)
self.assertTrue(p <= q)
self.assertTrue(q <= q)
self.assertTrue(q > p)
self.assertTrue(q >= p)
self.assertFalse(q < r)
self.assertFalse(q <= r)
self.assertFalse(q > r)
self.assertFalse(q >= r)
self.assertTrue(set('a').issubset('abc'))
self.assertTrue(set('abc').issuperset('a'))
self.assertFalse(set('a').issubset('cbs'))
self.assertFalse(set('cbs').issuperset('a'))
def test_gc(self):
# Create a nest of cycles to exercise overall ref count check
s = WeakSet(Foo() for i in range(1000))
for elem in s:
elem.cycle = s
elem.sub = elem
elem.set = WeakSet([elem])
def test_subclass_with_custom_hash(self):
# Bug #1257731
class H(WeakSet):
def __hash__(self):
return int(id(self) & 0x7fffffff)
s=H()
f=set()
f.add(s)
self.assertIn(s, f)
f.remove(s)
f.add(s)
f.discard(s)
def test_init(self):
s = WeakSet()
s.__init__(self.items)
self.assertEqual(s, self.s)
s.__init__(self.items2)
self.assertEqual(s, WeakSet(self.items2))
self.assertRaises(TypeError, s.__init__, s, 2);
self.assertRaises(TypeError, s.__init__, 1);
def test_constructor_identity(self):
s = WeakSet(self.items)
t = WeakSet(s)
self.assertNotEqual(id(s), id(t))
def test_hash(self):
self.assertRaises(TypeError, hash, self.s)
def test_clear(self):
self.s.clear()
self.assertEqual(self.s, WeakSet([]))
self.assertEqual(len(self.s), 0)
def test_copy(self):
dup = self.s.copy()
self.assertEqual(self.s, dup)
self.assertNotEqual(id(self.s), id(dup))
def test_add(self):
x = SomeClass('Q')
self.s.add(x)
self.assertIn(x, self.s)
示例7: __init__
# 需要导入模块: from weakref import WeakSet [as 别名]
# 或者: from weakref.WeakSet import discard [as 别名]
class Manager:
def __init__(self):
self.listeners = {}
self.cell_aliases = {}
self.cell_rev_aliases = {}
self.macro_listeners = {}
self.observers = {}
self.registrar_listeners = WeakKeyDictionary()
self.rev_registrar_listeners = WeakKeyDictionary()
self.pin_to_cells = {}
self.cells = WeakValueDictionary()
self.cell_to_output_pin = WeakKeyDictionary()
self._childids = WeakValueDictionary()
self.registrar_items = []
self.unstable_workers = WeakSet()
super().__init__()
def set_stable(self, worker, value):
assert value in (True, False), value
if not value:
#print("UNSTABLE", worker)
self.unstable_workers.add(worker)
else:
#print("STABLE", worker)
self.unstable_workers.discard(worker)
def add_cell_alias(self, source, target):
from .cell import Cell
assert isinstance(source, Cell)
assert isinstance(target, Cell)
assert source is not target
cell_id = self.get_cell_id(source)
target_ref = weakref.ref(target)
try:
aliases = self.cell_aliases[cell_id]
if target_ref not in aliases:
aliases.append(target_ref)
except KeyError:
self.cell_aliases[cell_id] = [target_ref]
if cell_id not in self.cells:
self.cells[cell_id] = source
#reverse alias
cell_id = self.get_cell_id(target)
source_ref = weakref.ref(source)
try:
rev_aliases = self.cell_rev_aliases[cell_id]
if source_ref not in rev_aliases:
rev_aliases.append(source_ref)
except KeyError:
self.cell_rev_aliases[cell_id] = [source_ref]
if cell_id not in self.cells:
self.cells[cell_id] = target
def add_registrar_item(self, registrar_name, dtype, data, data_name):
item = registrar_name, dtype, data, data_name
for curr_item in self.registrar_items:
if data_name is None:
exists = (curr_item[:3] == item[:3])
else:
exists = (curr_item[:2] == item[:2]) and \
curr_item[3] == data_name
if exists:
raise ValueError("Registrar item already exists")
self.registrar_items.append(item)
def remove_registrar_item(self, registrar_name, dtype, data, data_name):
item = registrar_name, dtype, data, data_name
self.registrar_items.remove(item)
def add_listener(self, cell, input_pin):
cell_id = self.get_cell_id(cell)
pin_ref = weakref.ref(input_pin)
try:
listeners = self.listeners[cell_id]
assert pin_ref not in listeners
# TODO: tolerate (silently ignore) a connection that exists already?
listeners.append(pin_ref)
except KeyError:
self.listeners[cell_id] = [pin_ref]
try:
curr_pin_to_cells = self.pin_to_cells[input_pin.get_pin_id()]
assert cell_id not in curr_pin_to_cells
# TODO: tolerate (append) multiple inputs?
curr_pin_to_cells.append(cell_id)
except KeyError:
self.pin_to_cells[input_pin.get_pin_id()] = [cell_id]
if cell_id not in self.cells:
#.........这里部分代码省略.........
示例8: AsyncoreLoop
# 需要导入模块: from weakref import WeakSet [as 别名]
# 或者: from weakref.WeakSet import discard [as 别名]
class AsyncoreLoop(object):
def __init__(self):
self._loop_lock = Lock()
self._started = False
self._shutdown = False
self._conns_lock = Lock()
self._conns = WeakSet()
def maybe_start(self):
should_start = False
did_acquire = False
try:
did_acquire = self._loop_lock.acquire(False)
if did_acquire and not self._started:
self._started = True
should_start = True
finally:
if did_acquire:
self._loop_lock.release()
if should_start:
thread = Thread(target=self._run_loop, name="cassandra_driver_event_loop")
thread.daemon = True
thread.start()
atexit.register(partial(self._cleanup, thread))
def _run_loop(self):
log.debug("Starting asyncore event loop")
with self._loop_lock:
while True:
try:
asyncore.loop(timeout=0.001, use_poll=True, count=1000)
except Exception:
log.debug("Asyncore event loop stopped unexepectedly", exc_info=True)
break
if self._shutdown:
break
with self._conns_lock:
if len(self._conns) == 0:
break
self._started = False
log.debug("Asyncore event loop ended")
def _cleanup(self, thread):
self._shutdown = True
log.debug("Waiting for event loop thread to join...")
thread.join()
log.debug("Event loop thread was joined")
def connection_created(self, connection):
with self._conns_lock:
self._conns.add(connection)
def connection_destroyed(self, connection):
with self._conns_lock:
self._conns.discard(connection)
示例9: ROBroker
# 需要导入模块: from weakref import WeakSet [as 别名]
# 或者: from weakref.WeakSet import discard [as 别名]
class ROBroker(object):
"""
Helper class which simplifies handling of range observers.
Can be used as a mixin or standalone.
"""
implements(IRangeObservable)
__robservers = None
def addRangeObserver(self, rangeObserver):
assert IRangeObserver.providedBy(rangeObserver)
if self.__robservers == None:
self.__robservers = WeakSet()
self.__robservers.add(rangeObserver)
def removeRangeObserver(self, rangeObserver):
assert IRangeObserver.providedBy(rangeObserver)
if self.__robservers == None:
return
self.__robservers.discard(rangeObserver)
def notifyRangeWillChange(self, rangeFrom, rangeTo, srcobject=None):
"""
Call this to inform the respective observers of an impending range
change.
You must call `notifyRangeDidChange()` after you performed the
range change. The call is not stackable.
"""
if srcobject == None:
srcobject = self
self.__rangeFrom = rangeFrom
self.__rangeTo = rangeTo
self.__srcobject = srcobject
if self.__robservers != None:
for rangeObserver in set(self.__robservers):
rangeObserver.observedRangeWillChange(srcobject, rangeFrom, rangeTo)
def notifyRangeDidChange(self):
"""
Call this to inform the respective observers of a performed range
change.
You must have called `notifyRangeWillChange()` before.
"""
if self.__robservers != None:
for rangeObserver in set(self.__robservers):
rangeObserver.observedRangeDidChange(self.__srcobject, self.__rangeFrom, self.__rangeTo)
del self.__rangeFrom
del self.__rangeTo
del self.__srcobject
def notifyRangeWillIncrease(self, rangeFrom, rangeTo, srcobject=None):
"""
Call this to inform the respective observers of an impending range
increase.
You must call `notifyRangeDidIncrease()` after you performed the
range increase. The call is not stackable.
"""
if srcobject == None:
srcobject = self
self.__rangeFrom = rangeFrom
self.__rangeTo = rangeTo
self.__srcobject = srcobject
if self.__robservers != None:
for rangeObserver in set(self.__robservers):
rangeObserver.observedRangeWillIncrease(srcobject, rangeFrom, rangeTo)
def notifyRangeDidIncrease(self):
"""
Call this to inform the respective observers of a performed range
increase.
You must have called `notifyRangeWillIncrease()` before.
"""
if self.__robservers != None:
for rangeObserver in set(self.__robservers):
rangeObserver.observedRangeDidIncrease(self.__srcobject, self.__rangeFrom, self.__rangeTo)
del self.__rangeFrom
del self.__rangeTo
del self.__srcobject
def notifyRangeWillDecrease(self, rangeFrom, rangeTo, srcobject=None):
"""
Call this to inform the respective observers of an impending range
#.........这里部分代码省略.........
示例10: SwitchboardManager
# 需要导入模块: from weakref import WeakSet [as 别名]
# 或者: from weakref.WeakSet import discard [as 别名]
class SwitchboardManager(gobject.GObject):
"""Switchboard management
@undocumented: do_get_property, do_set_property
@group Handlers: _handle_*, _default_handler, _error_handler"""
__gsignals__ = {
"handler-created": (gobject.SIGNAL_RUN_FIRST,
gobject.TYPE_NONE,
(object, object))
}
def __init__(self, client):
"""Initializer
@param client: the main Client instance"""
gobject.GObject.__init__(self)
self._client = weakref.proxy(client)
self._reset()
self._handlers_class = set()
self._client._protocol.connect("switchboard-invitation-received",
self._ns_switchboard_invite)
def _reset(self):
self._switchboards = {}
self._orphaned_switchboards = set()
self._requested_switchboards = {}
self._pending_switchboards = {}
self._orphaned_handlers = WeakSet()
def close(self):
for switchboard in self._orphaned_switchboards:
switchboard.leave()
for switchboard in self._pending_switchboards:
switchboard.leave()
for switchboard in self._switchboards:
switchboard.leave()
self._reset()
def register_handler_class(self, handler_class, *extra_arguments):
self._handlers_class.add((handler_class, extra_arguments))
def register_handler(self, handler):
self._orphaned_handlers.add(handler)
def request_switchboard(self, handler, priority=99):
handler_participants = handler.total_participants
participants = ", ".join(map(lambda c: c.account, handler_participants))
logger.info("Requesting switchboard for participant(s) %s" % participants)
# If the Handler was orphan, then it is no more
self._orphaned_handlers.discard(handler)
# Check already open switchboards
for switchboard in self._switchboards.keys():
switchboard_participants = set(switchboard.participants.values())
if handler_participants == switchboard_participants and \
(switchboard.state == msnp.ProtocolState.OPEN or \
switchboard.state == msnp.ProtocolState.OPENING):
logger.info("Using already opened switchboard %s" %
switchboard.session_id)
self._switchboards[switchboard].add(handler)
handler._switchboard = switchboard
return
# Check Orphaned switchboards
for switchboard in list(self._orphaned_switchboards):
switchboard_participants = set(switchboard.participants.values())
if handler_participants == switchboard_participants and \
(switchboard.state == msnp.ProtocolState.OPEN or \
switchboard.state == msnp.ProtocolState.OPENING):
logger.info("Using orphaned switchboard %s" %
switchboard.session_id)
self._switchboards[switchboard] = set([handler]) #FIXME: WeakSet ?
self._orphaned_switchboards.discard(switchboard)
handler._switchboard = switchboard
return
# Check pending switchboards
for switchboard, handlers in self._pending_switchboards.iteritems():
pending_handler = handlers.pop()
handlers.add(pending_handler)
switchboard_participants = pending_handler.total_participants
if handler_participants == switchboard_participants:
self._pending_switchboards[switchboard].add(handler)
logger.info("Using pending switchboard")
return
# Check switchboards being requested for same participants
if participants in self._requested_switchboards:
self._requested_switchboards[participants].add(handler)
logger.info("Using already requested switchboard for same contacts")
return
logger.info("Requesting new switchboard")
self._requested_switchboards[participants] = set([handler])
self._client._protocol.request_switchboard(priority,
(self._ns_switchboard_request_response, participants))
#.........这里部分代码省略.........
示例11: Character
# 需要导入模块: from weakref import WeakSet [as 别名]
# 或者: from weakref.WeakSet import discard [as 别名]
#.........这里部分代码省略.........
"""
__tablename__ = 'characters'
id = Column('character_id', Integer, primary_key=True)
alias = Column(String)
def __init__(self, alias='', source=None):
self.__generic_init()
# Use default source, unless specified otherwise
if source is None:
source = SourceManager.default
self.source = source
self.alias = alias
@reconstructor
def _dbinit(self):
self.__generic_init()
# Use default source for all reconstructed characters
self.source = SourceManager.default
# Restore entities which are stored on character
for skill in self._skills:
self.skill.add(skill)
def __generic_init(self):
char_type_id = Type.character_static
EveItemWrapper.__init__(self, char_type_id)
# Attributes which store objects hidden behind properties
self.__source = None
# Set with fits which are loaded and use this character
self.__loaded_proxies = WeakSet()
self.skills = SkillCoreSet(self)
self._eos_fit = EosFit()
# EVE item wrapper methods
@property
def _source(self):
return self.source
@property
def _eos_item(self):
return self._eos_fit.character
@property
def _src_children(self):
return get_src_children(chain(
self.skills,
))
# Miscellanea public stuff
@property
def source(self):
return self.__source
@source.setter
def source(self, new_source):
# Attempt to fetch source from source manager if passed object
# is not instance of source class
if not isinstance(new_source, Source) and new_source is not None:
new_source = SourceManager.get(new_source)
old_source = self.source
# Do not update anything if sources are the same
if new_source is old_source:
return
self.__source = new_source
# Update eos model with new data
self._eos_fit.source = getattr(new_source, 'eos', None)
# Update pyfa model with new data
# Unlike fit, character represents EVE item, thus we need
# to update it too
self._update_source()
for src_child in self._src_children:
src_child._update_source()
persist = pyfa_persist
abandon = pyfa_abandon
def validate(self):
self._eos_fit.validate()
# Auxiliary methods
def _proxy_iter(self):
"""
Safe iterator over related character proxies, avoids issues
with set size getting changed by GC during iteration.
"""
for char_proxy in tuple(self.__loaded_proxies):
yield char_proxy
def _link_proxy(self, char_proxy):
"""Create connection between character core and proxy"""
self.__loaded_proxies.add(char_proxy)
def _unlink_proxy(self, char_proxy):
"""Remove connection between character core and proxy"""
self.__loaded_proxies.discard(char_proxy)
def __repr__(self):
spec = ['id']
return make_repr_str(self, spec)
示例12: TestWeakSet
# 需要导入模块: from weakref import WeakSet [as 别名]
# 或者: from weakref.WeakSet import discard [as 别名]
#.........这里部分代码省略.........
self.assertFalse(set('cbs').issuperset('a'))
def test_lt(self):
self.assertTrue(self.ab_weakset < self.abcde_weakset)
self.assertFalse(self.abcde_weakset < self.def_weakset)
self.assertFalse(self.ab_weakset < self.ab_weakset)
self.assertFalse(WeakSet() < WeakSet())
def test_gt(self):
self.assertTrue(self.abcde_weakset > self.ab_weakset)
self.assertFalse(self.abcde_weakset > self.def_weakset)
self.assertFalse(self.ab_weakset > self.ab_weakset)
self.assertFalse(WeakSet() > WeakSet())
def test_gc(self):
# Create a nest of cycles to exercise overall ref count check
s = WeakSet(Foo() for i in range(1000))
for elem in s:
elem.cycle = s
elem.sub = elem
elem.set = WeakSet([elem])
def test_subclass_with_custom_hash(self):
# Bug #1257731
class H(WeakSet):
def __hash__(self):
return int(id(self) & 0x7fffffff)
s=H()
f=set()
f.add(s)
self.assertIn(s, f)
f.remove(s)
f.add(s)
f.discard(s)
def test_init(self):
s = WeakSet()
s.__init__(self.items)
self.assertEqual(s, self.s)
s.__init__(self.items2)
self.assertEqual(s, WeakSet(self.items2))
self.assertRaises(TypeError, s.__init__, s, 2);
self.assertRaises(TypeError, s.__init__, 1);
def test_constructor_identity(self):
s = WeakSet(self.items)
t = WeakSet(s)
self.assertNotEqual(id(s), id(t))
def test_hash(self):
self.assertRaises(TypeError, hash, self.s)
def test_clear(self):
self.s.clear()
self.assertEqual(self.s, WeakSet([]))
self.assertEqual(len(self.s), 0)
def test_copy(self):
dup = self.s.copy()
self.assertEqual(self.s, dup)
self.assertNotEqual(id(self.s), id(dup))
def test_add(self):
x = ustr('Q')
self.s.add(x)
self.assertIn(x, self.s)
示例13: Window
# 需要导入模块: from weakref import WeakSet [as 别名]
# 或者: from weakref.WeakSet import discard [as 别名]
class Window(object):
supported_drag_types = [const.DOC_ID_LIST_PBOARD_TYPE, ak.NSFilenamesPboardType]
app = WeakProperty()
def __init__(self, app, state=None):
self.app = app
self._current_editor = None
self.wc = WindowController(self)
self.state = state
self.command = CommandBar(self, app.text_commander)
self.projects = KVOList()
self.recent = self._suspended_recent = RecentItemStack(100)
self._recent_history = None
self.window_settings_loaded = False
self.no_document_undo_manager = UndoManager()
self.menu = self.make_context_menu()
self.dirty_editors = WeakSet()
def window_did_load(self):
wc = self.wc
wc.docsView.default_menu = self.menu
wc.docsView.setRefusesFirstResponder_(True)
wc.docsView.registerForDraggedTypes_(self.supported_drag_types)
wc.plusButton.setRefusesFirstResponder_(True)
wc.plusButton.setImage_(load_image(const.PLUS_BUTTON_IMAGE))
wc.propsViewButton.setRefusesFirstResponder_(True)
wc.propsViewButton.setImage_(load_image(const.PROPS_DOWN_BUTTON_IMAGE))
wc.propsViewButton.setAlternateImage_(load_image(const.PROPS_UP_BUTTON_IMAGE))
self._setstate(self._state)
self._state = None
if not self.projects:
self.new_project()
def make_context_menu(self):
def has_path(item):
return item and item.file_path
return Menu([
MenuItem("Copy Path", self.copy_path, is_enabled=has_path),
MenuItem("Close", self.close_item, "Command+w"),
])
def _setstate(self, state):
if state:
projects = state.get("projects")
if projects is None:
projects = state.get("project_serials", []) # legacy
for serial in projects:
proj = Project(self, serial=serial)
self.projects.append(proj)
for proj_index, doc_index in state.get("recent_items", []):
if proj_index < len(self.projects):
proj = self.projects[proj_index]
if doc_index == "<project>":
self.recent.push(proj.id)
elif doc_index < len(proj.editors):
doc = proj.editors[doc_index]
self.recent.push(doc.id)
if 'window_settings' in state:
self.window_settings = state['window_settings']
with self.suspend_recent_updates():
pass # focus recent
def __getstate__(self):
if self._state is not None:
return self._state
def iter_settings():
indexes = {}
serials = []
for i, project in enumerate(self.projects):
serial = project.serialize()
if serial:
serials.append(serial)
indexes[project.id] = [i, "<project>"]
for j, doc in enumerate(project.editors):
indexes[doc.id] = [i, j]
yield "projects", serials
rits = []
for ident in self.recent:
pair = indexes.get(ident)
if pair is not None:
rits.append(pair)
yield "recent_items", rits
yield "window_settings", self.window_settings
return {key: val for key, val in iter_settings() if val}
def __setstate__(self, state):
assert not hasattr(self, '_state'), 'can only be called once'
self._state = state
state = property(__getstate__, __setstate__)
def discard(self, item):
ident = None if item is None else item.id
recent = self.recent
update_current = item in self.selected_items or not self.selected_items
with self.suspend_recent_updates(update_current):
for project in list(self.projects):
#.........这里部分代码省略.........