本文整理汇总了Python中weakref.WeakKeyDictionary.pop方法的典型用法代码示例。如果您正苦于以下问题:Python WeakKeyDictionary.pop方法的具体用法?Python WeakKeyDictionary.pop怎么用?Python WeakKeyDictionary.pop使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类weakref.WeakKeyDictionary
的用法示例。
在下文中一共展示了WeakKeyDictionary.pop方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: SettingsObjectID
# 需要导入模块: from weakref import WeakKeyDictionary [as 别名]
# 或者: from weakref.WeakKeyDictionary import pop [as 别名]
class SettingsObjectID(object):
"""
Simple descriptor used for SettingsObject subclasses which have dynamic ids.
"""
def __init__(self, type):
self.type = type
self.values = WeakKeyDictionary()
self.oldvalues = WeakKeyDictionary()
self.dirty = WeakKeyDictionary()
def __get__(self, obj, objtype):
if obj is None:
return self
try:
return self.values[obj]
except KeyError:
raise AttributeError("SettingsObject ID has not been defined")
def __set__(self, obj, value):
if not isinstance(value, self.type):
value = self.type(value)
# check whether the old value is the same as the new value
if obj in self.values and self.values[obj] == value:
return
self.dirty[obj] = obj in self.values
self.oldvalues[obj] = self.values.get(obj, value)
self.values[obj] = value
def isdirty(self, obj):
"""
Returns True if the ID has been changed on the specified configuration
object.
"""
return self.dirty.get(obj, False)
def clear_dirty(self, obj):
"""
Clears the dirty flag for the ID on the specified configuration object.
"""
del self.dirty[obj]
self.oldvalues[obj] = self.values[obj]
def get_old(self, obj):
return self.oldvalues.get(obj, None)
def undo(self, obj):
if obj in self.oldvalues:
self.dirty.pop(obj, None)
self.values[obj] = self.oldvalues[obj]
示例2: HubstorageMiddleware
# 需要导入模块: from weakref import WeakKeyDictionary [as 别名]
# 或者: from weakref.WeakKeyDictionary import pop [as 别名]
class HubstorageMiddleware(object):
def __init__(self):
self._seen = WeakKeyDictionary()
self.hsref = hsref.hsref
self.pipe_writer = pipe_writer
self.request_id_sequence = request_id_sequence
def process_spider_input(self, response, spider):
self.pipe_writer.write_request(
url=response.url,
status=response.status,
method=response.request.method,
rs=len(response.body),
duration=response.meta.get('download_latency', 0) * 1000,
parent=response.meta.get(HS_PARENT_ID_KEY),
fp=request_fingerprint(response.request),
)
self._seen[response] = next(self.request_id_sequence)
def process_spider_output(self, response, result, spider):
parent = self._seen.pop(response)
for x in result:
if isinstance(x, Request):
x.meta[HS_PARENT_ID_KEY] = parent
yield x
示例3: RDB
# 需要导入模块: from weakref import WeakKeyDictionary [as 别名]
# 或者: from weakref.WeakKeyDictionary import pop [as 别名]
class RDB(DependencyProvider):
def __init__(self, db):
self.rdb_connections = WeakKeyDictionary()
self.db = db
def setup(self):
service_name = self.container.service_name
rdb_config = self.container.config[RDB_KEY][service_name]
self.RDB_HOST = rdb_config['RDB_HOST']
self.RDB_PORT = rdb_config['RDB_PORT']
self.RDB_DB = self.db
def get_dependency(self, worker_ctx):
connection = r.connect(host=self.RDB_HOST,
port=self.RDB_PORT,
db=self.RDB_DB)
self.rdb_connections[worker_ctx] = connection
return connection
def worker_teardown(self, worker_ctx):
connection = self.rdb_connections.pop(worker_ctx)
try:
connection.close()
except AttributeError: # pragma: no cover
pass
示例4: HubstorageMiddleware
# 需要导入模块: from weakref import WeakKeyDictionary [as 别名]
# 或者: from weakref.WeakKeyDictionary import pop [as 别名]
class HubstorageMiddleware(object):
def __init__(self):
self._seen = WeakKeyDictionary()
def process_spider_input(self, response, spider):
parent = response.meta.get('_hsparent')
riq = hsref.job.requests.add(
parent=parent,
url=response.url,
status=response.status,
method=response.request.method,
rs=len(response.body),
duration=response.meta.get('download_latency', 0) * 1000,
ts=time.time() * 1000,
fp=request_fingerprint(response.request),
)
self._seen[response] = riq
def process_spider_output(self, response, result, spider):
parent = self._seen.pop(response)
for x in result:
if isinstance(x, Request):
x.meta['_hsparent'] = parent
yield x
示例5: DatabaseSession
# 需要导入模块: from weakref import WeakKeyDictionary [as 别名]
# 或者: from weakref.WeakKeyDictionary import pop [as 别名]
class DatabaseSession(DependencyProvider):
def __init__(self, declarative_base):
self.declarative_base = declarative_base
self.sessions = WeakKeyDictionary()
def setup(self):
service_name = self.container.service_name
decl_base_name = self.declarative_base.__name__
uri_key = '{}:{}'.format(service_name, decl_base_name)
db_uris = self.container.config[DB_URIS_KEY]
self.db_uri = db_uris[uri_key].format({
'service_name': service_name,
'declarative_base_name': decl_base_name,
})
self.engine = create_engine(self.db_uri)
def stop(self):
self.engine.dispose()
del self.engine
def get_dependency(self, worker_ctx):
session_cls = sessionmaker(bind=self.engine)
session = session_cls()
self.sessions[worker_ctx] = session
return session
def worker_teardown(self, worker_ctx):
session = self.sessions.pop(worker_ctx)
session.close()
示例6: WeakOrderedSet
# 需要导入模块: from weakref import WeakKeyDictionary [as 别名]
# 或者: from weakref.WeakKeyDictionary import pop [as 别名]
class WeakOrderedSet(MutableSet):
"""
Ordered set storing weak references to its items.
Based on a recipe by Raymond Hettinger
(http://code.activestate.com/recipes/576694-orderedset/).
"""
def __init__(self, iterable=None):
MutableSet.__init__(self)
self.end = end = []
end += [None, end, end] # sentinel node for doubly linked list
self.map = WeakKeyDictionary() # key --> [key, prev, next]
if iterable is not None:
self |= iterable
def __len__(self):
return len(self.map)
def __contains__(self, key):
return key in self.map
def add(self, key):
if key not in self.map:
end = self.end
curr = end[1]
curr[2] = end[1] = self.map[key] = [key, curr, end]
def discard(self, key):
if key in self.map:
key, prev, nxt = self.map.pop(key)
prev[2] = nxt
nxt[1] = prev
def __iter__(self):
end = self.end
curr = end[2]
while curr is not end:
yield curr[0]
curr = curr[2]
def __reversed__(self):
end = self.end
curr = end[1]
while curr is not end:
yield curr[0]
curr = curr[1]
def pop(self, last=True):
if not self:
raise KeyError('set is empty')
key = self.end[1][0] if last else self.end[2][0]
self.discard(key)
return key
def __eq__(self, other):
if isinstance(other, WeakOrderedSet):
is_eq = len(self) == len(other) and list(self) == list(other)
else:
is_eq = set(self) == set(other)
return is_eq
示例7: Strucutre
# 需要导入模块: from weakref import WeakKeyDictionary [as 别名]
# 或者: from weakref.WeakKeyDictionary import pop [as 别名]
class Strucutre(INodeInvokerListener):
'''
The general structure.
'''
__slots__ = ('structNodes', 'typesPaths')
def __init__(self):
'''
Construct the structure.
'''
self.structNodes = WeakKeyDictionary()
self.typesPaths = WeakKeyDictionary()
def onInvokerChange(self, node, old, new):
'''
@see: INodeInvokerListener.onInvokerChange
'''
self.structNodes.pop(node, None)
self.typesPaths.pop(node, None)
# ----------------------------------------------------------------
def process(self, node, invoker):
'''
Process the structure for the provided node and invoker.
@param node: Node
The node to process for.
@param invoker: Invoker
The invoker to process.
@return: tuple(list[TypeProperty], @see: StructNode.process)|None
The list of path property types.
'''
assert isinstance(node, Node), 'Invalid node %s' % node
structNode = self.structNodes.get(node)
if structNode is None: structNode = self.structNodes[node] = StructNode()
assert isinstance(structNode, StructNode)
data = structNode.process(invoker)
if data is None: return
typesPath = self.typesPaths.get(node)
if typesPath is None: typesPath = self.typesPaths[node] = (propertyTypesOf(node, invoker),)
return typesPath + data
示例8: __init__
# 需要导入模块: from weakref import WeakKeyDictionary [as 别名]
# 或者: from weakref.WeakKeyDictionary import pop [as 别名]
class Manager:
"""Keeps a list of registered 'listeners' and sends each of them events
that they might be interested in.
"""
def __init__(self):
# Uses WeakKey because if listener is deleted elsewhere, this does not
# need to continue referencing it.
self.listeners = WeakKeyDictionary()
def register(self, listener):
"""Adds listener to the list of registered listeners."""
listener.manager = self
self.listeners[listener] = 1
def unregister(self, listener):
"""Remove a listener from the list of registered listeners."""
self.listeners.pop(listener, None)
def post(self, event):
"""Forward the given event to all listeners"""
for listener in self.listeners:
listener.getEvent(event)
示例9: ChanjoConnection
# 需要导入模块: from weakref import WeakKeyDictionary [as 别名]
# 或者: from weakref.WeakKeyDictionary import pop [as 别名]
class ChanjoConnection(DependencyProvider):
"""Interface to open an authenticated connection to the backend."""
def __init__(self):
self.sessions = WeakKeyDictionary()
def setup(self):
self.auth = self.container.config["chanjo"]["auth"]
def get_dependency(self, worker_ctx):
store = chanjo.Store(**self.auth)
self.sessions[worker_ctx] = store.session
return store
def worker_teardown(self, worker_ctx):
session = self.sessions.pop(worker_ctx)
session.close()
示例10: MinerConnection
# 需要导入模块: from weakref import WeakKeyDictionary [as 别名]
# 或者: from weakref.WeakKeyDictionary import pop [as 别名]
class MinerConnection(DependencyProvider):
"""Interface to open an authenticated connection to the report api."""
def __init__(self):
self.sessions = WeakKeyDictionary()
def setup(self):
self.auth = self.container.config["chanjo"]["auth"]
def get_dependency(self, worker_ctx):
chanjo_api = Miner(**self.auth)
self.sessions[worker_ctx] = chanjo_api.session
return chanjo_api
def worker_teardown(self, worker_ctx):
session = self.sessions.pop(worker_ctx)
session.close()
示例11: MongoEngineConnection
# 需要导入模块: from weakref import WeakKeyDictionary [as 别名]
# 或者: from weakref.WeakKeyDictionary import pop [as 别名]
class MongoEngineConnection(DependencyProvider):
"""Interface to open an authenticated connection to the backend."""
def __init__(self):
self.connections = WeakKeyDictionary()
def setup(self):
self.auth = self.container.config['scout']['auth']
if self.auth.get('db') is None:
raise AttributeError('must specify a database to connect to')
def get_dependency(self, worker_ctx):
connection = connect(**self.auth)
self.connections[worker_ctx] = connection
return connection
def worker_teardown(self, worker_ctx):
connection = self.connections.pop(worker_ctx)
connection.close()
示例12: DatabaseConnection
# 需要导入模块: from weakref import WeakKeyDictionary [as 别名]
# 或者: from weakref.WeakKeyDictionary import pop [as 别名]
class DatabaseConnection(DependencyProvider):
"""Interface to open an authenticated connection to the backend."""
def __init__(self):
self.sessions = WeakKeyDictionary()
def setup(self):
self.auth = self.container.config.get('status', {}).get('auth', {})
if self.auth['uri'] is None:
logger.debug('setting default/temp data store')
self.auth['uri'] = '/tmp/status.sqlite3'
def get_dependency(self, worker_ctx):
database = Store(**self.auth)
self.sessions[worker_ctx] = database.session
return database
def worker_teardown(self, worker_ctx):
session = self.sessions.pop(worker_ctx)
session.close()
示例13: TabooConnection
# 需要导入模块: from weakref import WeakKeyDictionary [as 别名]
# 或者: from weakref.WeakKeyDictionary import pop [as 别名]
class TabooConnection(DependencyProvider):
"""Interface to open an authenticated connection to the backend."""
def __init__(self):
self.sessions = WeakKeyDictionary()
def setup(self):
self.uri = (self.container.config['taboo'].get('auth', {})
.get('uri', '/tmp/taboo.sqlite3'))
self.reference = self.container.config['taboo']['reference']
def get_dependency(self, worker_ctx):
database = Database(self.uri)
database.reference = self.reference
database.query = database.session.query
self.sessions[worker_ctx] = database.session
return database
def worker_teardown(self, worker_ctx):
session = self.sessions.pop(worker_ctx)
session.close()
示例14: QNotebook
# 需要导入模块: from weakref import WeakKeyDictionary [as 别名]
# 或者: from weakref.WeakKeyDictionary import pop [as 别名]
#.........这里部分代码省略.........
result : QNotebook.SizeHintMode
The size hint mode enum value for the notebook.
"""
return self._size_hint_mode
def setSizeHintMode(self, mode):
""" Set the size hint mode of the notebook.
Parameters
----------
mode : QNotebook.SizeHintMode
The size hint mode for the notebook.
"""
assert isinstance(mode, QNotebook.SizeHintMode)
self._size_hint = QSize()
self._min_size_hint = QSize()
self._size_hint_mode = mode
def showPage(self, page):
""" Show a hidden QPage instance in the notebook.
If the page is not owned by the notebook, this is a no-op.
Parameters
----------
page : QPage
The hidden QPage instance to show in the notebook.
"""
index = self.indexOf(page)
if index == -1:
index = self._hidden_pages.pop(page, -1)
if index != -1:
self.insertPage(index, page)
def hidePage(self, page):
""" Hide the given QPage instance in the notebook.
If the page is not owned by the notebook, this is a no-op.
Parameters
----------
page : QPage
The QPage instance to hide in the notebook.
"""
index = self.indexOf(page)
if index != -1:
self.removeTab(index)
page.hide()
self._hidden_pages[page] = index
def addPage(self, page):
""" Add a QPage instance to the notebook.
This method should be used in favor of the 'addTab' method.
Parameters
----------
page : QPage
The QPage instance to add to the notebook.
"""
self.insertPage(self.count(), page)
示例15: __init__
# 需要导入模块: from weakref import WeakKeyDictionary [as 别名]
# 或者: from weakref.WeakKeyDictionary import pop [as 别名]
class Map:
def __init__(self, size):
self.rect = size.to_rect(Point.origin())
self.entity_positions = WeakKeyDictionary()
self.portal_index = {}
self.tiles = {
point: Tile(self, point)
for point in self.rect.iter_points()
}
_player = None
@property
def player(self):
assert self._player is not None, "map is missing a player!"
return self._player
@player.setter
def player(self, value):
assert self._player is None, "trying to set player when we've already got one! {} {}".format(id(self._player), id(value))
self._player = value
@player.deleter
def player(self):
assert self._player is not None, "can't remove nonexistent player!"
del self._player
@property
def rows(self):
for y in self.rect.range_height():
yield (self.tiles[Point(x, y)] for x in self.rect.range_width())
def place(self, entity, position):
assert entity not in self.entity_positions
self.entity_positions[entity] = position
self.tiles[position].attach(entity)
if entity.isa(Player):
self.player = entity
if IPortal in entity.type.components:
dest = IPortal(entity).destination
assert dest not in self.portal_index
self.portal_index[dest] = entity
def find(self, entity):
assert isinstance(entity, Entity)
pos = self.entity_positions[entity]
return self.tiles[pos]
def move(self, entity, position):
old_position = self.entity_positions[entity]
old_tile = self.tiles[old_position]
old_tile.detach(entity)
self.entity_positions[entity] = position
new_tile = self.tiles[position]
new_tile.attach(entity)
def remove(self, entity):
position = self.entity_positions.pop(entity)
self.tiles[position].detach(entity)
if entity.isa(Player):
del self.player
if IPortal in entity.type.components:
dest = IPortal(entity).destination
del self.portal_index[dest]
def __contains__(self, position):
return position in self.rect