Python WeakKeyDictionary.pop方法代码示例

# 需要导入模块: 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]

# 需要导入模块: 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

# 需要导入模块: 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

# 需要导入模块: 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

# 需要导入模块: 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()

# 需要导入模块: 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

# 需要导入模块: 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

# 需要导入模块: 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)

# 需要导入模块: 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()

# 需要导入模块: 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()

# 需要导入模块: 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()

# 需要导入模块: 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()

# 需要导入模块: 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()

# 需要导入模块: 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)

# 需要导入模块: 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