class AdapterRegistry(object):
    """ Registry of adapters"""

    _sentinel = object()

    def __init__(self):
        self.underlying = adapter.AdapterRegistry()
        self.cache = LRUCache(500)

    def lookup_adapter(self, typ):
        """ Lookup adapter for ``typ``"""
        adapter = self.cache.get(typ, self._sentinel)
        if adapter is self._sentinel:
            adapter = self.underlying.lookup([typ], IJSONSerializeable, "")
            self.cache.put(typ, adapter)
        return adapter

    def register_adapter(self, typ, adapter=None):
        """ Register ``adapter`` for type ``typ``

        If no ``adapter`` supplied then this method returns decorator.
        """
        if adapter is None:
            def decorator(adapter):
                self.register_adapter_impl(typ, adapter)
                return adapter
            return decorator
        return self.register_adapter_impl(typ, adapter)

    def register_adapter_impl(self, typ, adapter):
        self.underlying.register(
            [implementedBy(typ)], IJSONSerializeable, "", adapter)
        self.cache.clear()

class LRUCache(StorageInterface):
    """In memory LRU cache"""

    def __init__(self, max_size=1024):
        if max_size < 1:
            raise ValueError("max_size must be a positive integer greater than 0")
        self.max_size = max_size
        self.engine = LRUCacheEngine(max_size)

    def __getitem__(self, key):
        value = self.engine.get(key)
        if value is None:
            raise KeyError
        return value

    def __setitem__(self, key, value):
        self.engine.put(key, value)

    def __contains__(self, key):
        value = self.engine.get(key)
        if value is not None:
            return True
        else:
            return False

    def __len__(self):
        return self.max_size

class StaticsMiddleware(object):
    def _adapt_path(self, path):
        return normcase(normpath(path))

    def __init__(self, app, root_dir, cache_max_age=3600):
        self.app = app
        self.cache_max_age = cache_max_age
        self.doc_root = self._adapt_path(root_dir)
        self.paths_cache = LRUCache(1024)

    def __call__(self, environ, start_response):
        full_path = environ['PATH_INFO']
        filepath = self.paths_cache.get(full_path)

        if filepath is None:
            path = full_path.split('/')
            if INVALID_PATH_PARTS(path):
                return HTTPNotFound('Out of bounds: %s' % environ['PATH_INFO'])(environ, start_response)
            filepath = self._adapt_path(join(self.doc_root, *path))
            self.paths_cache.put(full_path, filepath)

        if isfile(filepath):
            return FileServeApp(filepath, self.cache_max_age)(environ, start_response)

        return self.app(environ, start_response)

 def __init__(self, key_lookup, component_cache_size, all_cache_size,
              fallback_cache_size):
     self.key_lookup = key_lookup
     self.predicate_key = key_lookup.predicate_key
     self.key_dict_to_predicate_key = key_lookup.key_dict_to_predicate_key
     self.component_cache = LRUCache(component_cache_size)
     self.all_cache = LRUCache(all_cache_size)
     self.fallback_cache = LRUCache(fallback_cache_size)

 def __init__(
         self, namespace=BASE_NAMESPACE, base_url=None,
         long_timeout=600):
     self.namespace = namespace
     self._client = TimeoutClient(
         version="1.15", base_url=base_url, long_timeout=long_timeout)
     self._image_cache = LRUCache(100)

 def __init__(self, dict=None, **kwargs):
     self.data = {}
     self._lkpcache = LRUCache(1000)
     if dict is not None:
         self.update(dict)
     if len(kwargs):
         self.update(kwargs)
     self.listener_registered = False # at least one listener registered

 def __init__(
         self, namespace=BASE_NAMESPACE, base_url=None,
         long_timeout=600):
     self.namespace = namespace
     self._client = dockerpy_client(
         version="1.15", base_url=base_url,
         long_timeout=timedelta(seconds=long_timeout),
     )
     self._image_cache = LRUCache(100)

class ClusterCache(object):
    def __init__(self, cache_size):
        self.lru = LRUCache(cache_size)
        self.hits = 0
        self.misses = 0

    def get(self, file_buffer, ptr):
        v = self.lru.get((file_buffer, ptr))
        if v is not None:
            self.hits += 1
            return v
        v = ClusterData(file_buffer, ptr)
        self.lru.put((file_buffer, ptr), v)
        self.misses += 1
        return v

    def clear(self):
        logger.debug("CACHE HITS " + str(self.hits) + " VS MISSES " + str(self.misses))
        self.lru.clear()

    def __init__(self, wiki, page_urls, registry_size=None):
        self.wiki = wiki
        self.page_urls = page_urls

        self._cache = LRUCache(registry_size or self.PAGE_REGISTRY_SIZE)
        self._pages_meta = None

        self._queue = None
        self._results = None
        self._pool = None
        self._done = False

 def __init__(self, basedir, notify_on_commit):
     self.basedir = basedir
     self._notify_on_commit = notify_on_commit
     self._changelog_cache = LRUCache(1000)  # is thread safe
     with self.get_sqlconn() as conn:
         row = conn.execute("select max(serial) from changelog").fetchone()
         serial = row[0]
         if serial is None:
             self.next_serial = 0
         else:
             self.next_serial = serial + 1
             # perform some crash recovery
             data = self.get_raw_changelog_entry(serial)
             changes, rel_renames = loads(data)
             check_pending_renames(str(self.basedir), rel_renames)

def partly_distinct(iterable):
    """
    Filters items from iterable and **tries to return only distincts**.
    Keeps order.

    :param Iterable iterable: Something iterable we have to filter.

    >>> list(partly_distinct([1, 2, 3, 2, 1, 2, 3, 4]))
    ... [1, 2, 3, 4]

    .. note::
        Unlike :py:func:`distinct` it won't guarantee that all elements would
        be distinct. But if you have rather small cardinality of the stream,
        this would work.

    .. note::
        Current implementation guarantees support for 10000 distinct values.
        If your cardinality is bigger, there might be some duplicates.
    """
    cache = LRUCache(10000)
    for item in iterable:
        if not cache.get(item):
            cache.put(item, True)
            yield item

    def __init__(self, name, server=None, create=False):
        self.server = server or Server()
        self.session = server.session
        self.name = name
        self.database = server.host + "/" + name

        self.cache = LRUCache(100)

        if create:
            self.create()
        else:
            response = self.session.head(self.database)
            if not response.ok:
                if response.status_code == 404:
                    raise excepts.DBNotExists
                raise Exception(response.status_code)

    def __init__(self):

        self.cli = False
        self.args = {}

        self.debug = False
        self.debug2 = False

        self.quiet = False

        self.profile = False

        self.components = OrderedDict()

        self.start_item = OrderedDict()
        self.start_nodes = []
        self.config_files = []
        self.included_files = []

        self.props = {}
        self.properties = self.props

        self.var = {}

        self.working_dir = os.getcwd()
        self.library_path = os.path.dirname(os.path.realpath(__file__)) + "/../../library"

        self.comp = Components(self)

        self._functions = {"text": functions,
                           "xml": xmlfunctions,
                           "datetime": datetime,
                           "dt": datetime,
                           "re": re,
                           "sys": sys,
                           "urllib": urllib,
                           "random": random.Random()}
        self._globals = self._functions

        class Functions():
            pass
        self.f = Functions()
        for k, v in self._functions.items():
            setattr(self.f, k, v)

        self._compiled = LRUCache(512)  # TODO: Configurable

class EDBag(Counter):
    def __init__(self):
        super(EDBag, self).__init__()
        self.cache1 = LRUCache(256) # values where distance=1
        self.cache2 = LRUCache(256) # values where distance>1

    def add(self, x):
        if not x in self:
            self.cache2.clear()
        self[x] += 1

    def closest_by_edit_distance(self, x):
        if x in self:
            # Optimization: if x is in multiset, then closest
            # edit dist = 0. Nothing can be any closer.
            return (x, 0)

        # Optimization: If we've looked up this value before, 
        # return previously computed answer.
        cached_answer = self.cache1.get(x)
        if cached_answer:
            return cached_answer
        cached_answer = self.cache2.get(x)
        if cached_answer:
            return cached_answer

        closest = None
        closest_dist = None
        for y,_ in self.most_common():
            d = editdistance.eval(x, y)
            if not closest_dist or d < closest_dist:
                closest = y
                closest_dist = d
                if d == 1:
                    # Optimization: nothing can be any closer, as
                    # we know there's nothing at edit distance 0 (x is not
                    # in the multiset).
                    self.cache1.put(x, (closest, closest_dist))
                    return (closest, closest_dist)

        self.cache2.put(x, (closest, closest_dist))
        return (closest, closest_dist)

    def __init__(self):

        self.args = {}

        self.debug = False
        self.debug2 = False

        self.quiet = False

        self.config_files = []

        self.start_node = None
        self.start_message = {}

        self.props = {}

        self._globals = {"text": text, "cubetl": cubetl}

        self._compiled = LRUCache(512)  # TODO: Configurable

        self.comp = Components(self)

class LRUShelf(Shelf):
    """An in-memory Least-Recently Used shelf up to `maxsize`.."""

    def __init__(self, maxsize=1000):
        self.store = LRUCache(int(maxsize))

    def getitem(self, key):
        value = self.store.get(key, UNSET)
        if value is UNSET:
            raise KeyError(key)
        return value

    def setitem(self, key, value):
        self.store.put(key, value)

    def delitem(self, key):
        self.store.invalidate(key)

    def clear(self):
        self.store.clear()

class RMemorySessionStore(Singleton):
    def __init__(self, config):
        self._cache = LRUCache(config.session_cache_size)

    def push(self, token_id, data):
        self._cache.put(token_id, data)

    def get(self, token):
        return self._cache.get(token, None)

    def remove(self, token_id):
        try:
            self._cache.put(token_id, None)
        except KeyError:
            pass

    def contains(self, session_id):
        return self._cache.get(session_id) is not None

class RMemorySessionStore(RUtils.singleton.Singleton):
    def __init__(self):
        if hasattr(self, '_init'):
            return
        self._init = True
        self.config = RUtils.config.RConfig()
        self._cache = LRUCache(self.config.session_cache_size)

    def push(self, token_id, data):
        self._cache.put(token_id, data)

    def get(self, token):
        return self._cache.get(token, None)

    def remove(self, session_id):
        try:
            self._cache.put(session_id, None)
        except KeyError:
            pass

    def contains(self, session_id):
        return self._cache.get(session_id) is not None

 def __init__(self):
     if hasattr(self, '_init'):
         return
     self._init = True
     config = RConfig()
     self._cache = LRUCache(config.session_cache_size)

class DockerClient(object):
    """
    Talk to the real Docker server directly.

    Some operations can take a while (e.g. stopping a container), so we
    use a thread pool. See https://clusterhq.atlassian.net/browse/FLOC-718
    for using a custom thread pool.

    :ivar unicode namespace: A namespace prefix to add to container names
        so we don't clobber other applications interacting with Docker.
    :ivar str base_url: URL for connection to the Docker server.
    :ivar int long_timeout: Maximum time in seconds to wait for
        long-running operations, particularly pulling an image.
    :ivar LRUCache _image_cache: Mapped cache of image IDs to their data.
    """
    def __init__(
            self, namespace=BASE_NAMESPACE, base_url=None,
            long_timeout=600):
        self.namespace = namespace
        self._client = dockerpy_client(
            version="1.15", base_url=base_url,
            long_timeout=timedelta(seconds=long_timeout),
        )
        self._image_cache = LRUCache(100)

    def _to_container_name(self, unit_name):
        """
        Add the namespace to the container name.

        :param unicode unit_name: The unit's name.

        :return unicode: The container's name.
        """
        return self.namespace + unit_name

    def _parse_container_ports(self, data):
        """
        Parse the ports from a data structure representing the Ports
        configuration of a Docker container in the format returned by
        ``self._client.inspect_container`` and return a list containing
        ``PortMap`` instances mapped to the container and host exposed ports.

        :param dict data: The data structure for the representation of
            container and host port mappings in a single container.
            This takes the form of the ``NetworkSettings.Ports`` portion
            of a container's state and configuration as returned by inspecting
            the container. This is a dictionary mapping container ports to a
            list of host bindings, e.g.
            "3306/tcp": [{"HostIp": "0.0.0.0","HostPort": "53306"},
                         {"HostIp": "0.0.0.0","HostPort": "53307"}]

        :return list: A list that is either empty or contains ``PortMap``
            instances.
        """
        ports = []
        for internal, hostmap in data.items():
            internal_map = internal.split(u'/')
            internal_port = internal_map[0]
            internal_port = int(internal_port)
            if hostmap:
                for host in hostmap:
                    external_port = host[u"HostPort"]
                    external_port = int(external_port)
                    portmap = PortMap(internal_port=internal_port,
                                      external_port=external_port)
                    ports.append(portmap)
        return ports

    def _parse_restart_policy(self, data):
        """
        Parse the restart policy from the configuration of a Docker container
        in the format returned by ``self._client.inspect_container`` and return
        an ``IRestartPolicy``.

        :param dict data: The data structure representing the restart policy of
            a container, e.g.

            {"Name": "policy-name", "MaximumRetryCount": 0}

        :return IRestartPolicy: The model of the restart policy.

        :raises ValueError: if an unknown policy is passed.
        """
        POLICIES = {
            u"": lambda data:
                RestartNever(),
            u"always": lambda data:
                RestartAlways(),
            u"on-failure": lambda data:
                RestartOnFailure(
                    maximum_retry_count=data[u"MaximumRetryCount"] or None)
        }
        try:
            # docker will treat an unknown plolicy as "never".
            # We error out here, in case new policies are added.
            return POLICIES[data[u"Name"]](data)
        except KeyError:
            raise ValueError("Unknown restart policy: %r" % (data[u"Name"],))

    def _serialize_restart_policy(self, restart_policy):
#.........这里部分代码省略.........