def setup_nodes(g):
    for cdn in cdns:
        g.node[cdn]["storage"] = CDNStorage()
        g.node[cdn]["color"] = "#ff0000"
        g.node[cdn]["capacity"] = cdn_capacity
        g.node[cdn]["size"] = 50
        g.node[cdn]["type"] = "CDN"

    for vcdn_node in vcdns:
        g.node[vcdn_node]["storage"] = pylru.lrucache(vcdn_cache_size)
        #g.node[vcdn_node]["storage"] = CDNStorage()
        g.node[vcdn_node]["capacity"] = vcdn_capacity
        g.node[vcdn_node]["type"] = "VCDN"
        g.node[vcdn_node]["color"] = "#00ff00"
        g.node[vcdn_node]["size"] = 20

    for mucdn_node in mucdns:
        g.node[mucdn_node]["storage"] = pylru.lrucache(mucdn_cache_size)
        #g.node[mucdn_node]["storage"] = CDNStorage()
        g.node[mucdn_node]["capacity"] = mucdn_capacity
        g.node[mucdn_node]["size"] = 10
        g.node[mucdn_node]["type"] = "MUCDN"
        g.node[mucdn_node]["color"] = "#aaaaff"

    for consumer in consumers:
        g.node[consumer]["color"] = "#000000"
        g.node[consumer]["size"] = 5
        g.node[mucdn_node]["type"] = "CONSUMER"

 def __init__(self, left, right, target, max_size=128):
     super().__init__()
     self.__cache_left = pylru.lrucache(size=max_size)
     self.__cache_right = pylru.lrucache(size=max_size)
     self.__left = left
     self.__right = right
     self.__target = target
     self.__max_size = max_size

def LoadCacheFromFile(filename):
  """
  This function returns a pylru.lrucache object containing (key, value) pairs.
  The keys are strings containing the URLs of submissions. The values are just
  dummy values to be ignored. We try to read the file whose name is given as an
  argument. If we can, we return a pylru.lrucache object containing its
  contents, with the top line of the file being the most recently used entry
  and the last line of the file being the least recently used entry. If we
  cannot read the file, we return an empty pylru.lrucache object. This function
  should return a cache containing the same state as the cache last passed to
  StoreCacheToFile().
  """
  cache = pylru.lrucache(MAX_SUBMISSIONS)

  try:
    f = open(filename)
    contents = f.readlines()
    f.close()
  except:  # Can't read the file; give up and start from scratch.
    print "WARNING: Unable to load cache. Starting over with an empty cache."
    return cache

  # The most recently used line is first in the file, which means it should be
  # inserted into the cache last.
  for line in reversed(contents):
    cache[line.strip()] = True  # Dummy value
  return cache

    def __init__(self, available_registers, spill_memory_base_label, spill_memory_size, word_size=4):
        """ The constructor.

        Creates a RegisterUseTable with it's allowed set of registers and available spill memory. Arbitrarily sized
        words are allowed, but (sensible) 4 byte words are used by default.

        :param available_registers: A sequence (preferably set or tuple) of the registers the table is allowed to use
                                    without reservation.
        :spill_memory_base_label: The MIPS label where the spill memory is located.
        :param spill_memory_size: The amount of spill memory available in bytes.
        :word_size: The size of a word (register capacity) in bytes.
        :return: A constructed RegisterUseTable object.
        """

        self.spill_mem_base_label = spill_memory_base_label
        self.spill_mem_size = spill_memory_size

        self.available_registers = list(reversed(available_registers))
        self.available_spill_memory_words = list(reversed(range(0, spill_memory_size, word_size)))

        self.lru_cache = pylru.lrucache(size=len(available_registers), callback=self._spill)
        self.spilled_registers = {}

        self._spill_code = []
        self._freed_physical_register = None

    def register_cache(cls, key, size=512):
        """Create a new cache for this entity, keyed by attribute.

        Currently these caches are not searched, they merely serve as another
        reference to keep their entries in _instances alive.

        There is support for caching UIDs and Attribute values when
        they change, if you want to register anything else (such as bare
        properties not tied to an Attribute) then you'll need to make sure to
        update the cache yourself when their values change.

        :param str key: The attribute name to use as a key
        :param int size: The size of the cache to create
        :returns None:
        :raises KeyError: If a cache already exists for `key`

        """
        if key in cls._caches:
            raise AlreadyExists(key, cls._caches[key])
        cache = lrucache(size, cls._cache_eject_callback)
        cls._caches[key] = cache
        # Fill the cache with any existing entity data.
        for entity in cls._instances.values():
            attr_value = getattr(entity, key)
            if attr_value not in (None, Unset):
                if attr_value not in cache:
                    cache[attr_value] = {entity}
                else:
                    cache[attr_value].add(entity)

 def load_cache(self):
     '''Create a pylru.lrucache object prepopulated with saved data.'''
     cache = pylru.lrucache(self.size)
     # There should be a more efficient way to do this, by hooking into
     # the json module directly.
     self._populate_cache_from_file(self.filename, cache)
     return cache

 def __init__(self,file_cache_count = 200,threshold=1000,buckets=60):
     self.file_cache = pylru.lrucache(file_cache_count)
     self.buckets = buckets
     self.threshold = threshold
     self.event_index = 0
     self.event_counts = {}
     self.event_total = 0

	def __init__(self, basefolder, create=False):
		"""
		Initializes a ``LocalFileStorage`` instance under the given ``basefolder``, creating the necessary folder
		if necessary and ``create`` is set to ``True``.

		:param string basefolder: the path to the folder under which to create the storage
		:param bool create:       ``True`` if the folder should be created if it doesn't exist yet, ``False`` otherwise
		"""
		self._logger = logging.getLogger(__name__)

		self.basefolder = os.path.realpath(os.path.abspath(basefolder))
		if not os.path.exists(self.basefolder) and create:
			os.makedirs(self.basefolder)
		if not os.path.exists(self.basefolder) or not os.path.isdir(self.basefolder):
			raise RuntimeError("{basefolder} is not a valid directory".format(**locals()))

		import threading
		self._metadata_lock = threading.Lock()

		self._metadata_cache = pylru.lrucache(10)

		from slugify import Slugify
		self._slugify = Slugify()
		self._slugify.safe_chars = "-_.() "

		self._old_metadata = None
		self._initialize_metadata()

 def __init__(self, size=10):
     """
     :param size: int, size of the cache, should match the actual concurrent users,
                 as we should only assign one key-value for one user
     :return:
     """
     self.cache = pylru.lrucache(size)
     self.size = size

def lrucache(size):
    try:
        #raise ImportError("no pylru")
        import pylru
        return pylru.lrucache(size)
    except ImportError:
        warnings.warn("pylru not available; using simple cache with no size limit")
        return {}

  def __init__(self, options):
    """Initializes an LruBackend.

    Args:
      options: a dictionary that contains configuration options.
    """
    capacity = options["capacity"] if "capacity" in options else 200
    self._cache = pylru.lrucache(capacity)

    def __init__(self, size=1024):
        try:
            import pylru
        except ImportError:
            raise ImportError("Could not find pylru.  This packages is " +
                              "required when using ores.score_caches.LRU.")

        self.lru = pylru.lrucache(size)

 def __init__(self, index_dir):
     self.index_dir = index_dir
     self.catalog_map = None
     self.doc_id_map = None
     self.id_doc_map = dict()
     self.dlen_map = None
     self.token_id_map = None
     self.index_file = None
     self.mem_cache = pylru.lrucache(10000)
     self.load_meta()

    def __init__(self, name, maxSize = 1000000):

        self._store = pylru.lrucache(maxSize)
        self._name = name
        self._start = time.time()
        self._numWrites = 0
        self._numReads = 0
        self._numHits = 0
        self._numMisses = 0
        self.getStats()

def pmemoize(obj):
    cache = obj.cache = pylru.lrucache(500)

    @functools.wraps(obj)
    def memoizer(*args, **kwargs):
        key = marshal.dumps([args, kwargs])
        if key not in cache:
            cache[key] = obj(*args, **kwargs)
        return cache[key]
    return memoizer

def get_cache(size=10000):
    if memcache_host:
        host = memcache_host.split(":")
        kw = {
            "binary": True,
            "behaviors": {"tcp_nodelay": True, "ketama": True},
        }
        return pylibmc.Client(host, **kw)
    else:
        return pylru.lrucache(size)

def run(weights, num_bins, capacity=1, lower_bound=-1):
    """Finds the best feasible upper bound within given limits

    Keyword arguments:
    weights -- the set of allowed weights
    num_bins -- number of bins
    capacity -- bins capacity

    Return maximal capacity required
    (stretching factor = ret / capacity)
    """
    bins = bin_factory(num_bins, capacity)

    # Keep only feasible weights
    ws = []
    for w in weights:
        if w <= capacity:
            ws.append(w)

    # Sort items by decreasing order of their weights
    ws.sort(reverse=True)
    # WARNING: if the order is changed then, feasibility has to be verified
    # for every item ! cf boolean feasibilityVerified in branch()

    init_solver(SOLVER, jarpath)
    if SOLVER == "CHOCO" or SOLVER == "CP":
        run_jvm(jvmpath, jarpath)

    # Create cache
    if cache_size <= 0: d = {}
    else: d = lrucache(cache_size)

    if lower_bound < 0:
        lower_bound = capacity

    root=TreeNode()
    root.attr['Name']="Root"
    val = branch(ws, bins, num_bins*capacity, lower_bound, 26.*capacity/17.,
            d, backtrack=root)
    root.set_input()
    #strftime("%Y-%m-%d %H:%M:%S", gmtime())
    f = open('backtrack.dot', 'w')
    f.write(root.dot())
    f.close()

    terminate_solver(SOLVER)

    """ Memory profiling
    from guppy import hpy
    h = hpy()
    print h.heap()
    """

    return val

    def __init__(self, properties):
        settings = zc.mappingobject.mappingobject(properties)
        self.cache_size = settings.cache_size
        self.cache = pylru.lrucache(self.cache_size)
        self.hitrates = Sample()

        @properties
        def changed(*a):
            if settings.cache_size != self.cache_size:
                self.cache_size = settings.cache_size
                self.cache.size(self.cache_size)

    def __init__(self, **kwargs):
        """
        Initializer

        ARGS: kwargs
            - MAX_MSG_TYPE_CACHE_SIZE: Maximum size of the LRU cache around
              msg_types
        """

        _msg_type_cache_size = kwargs.get('MAX_MSG_TYPE_CACHE_SIZE', 1024)
        self._msg_type_cache = pylru.lrucache(_msg_type_cache_size)

    def register_cache(cls, key, size=512):
        """Create a new cache for this entity, keyed by attribute.

        :param str key: The attribute name to use as a key
        :param int size: The size of the cache to create
        :returns None:
        :raises KeyError: If a cache already exists for `key`

        """
        if key in cls._caches:
            raise KeyError(joins("entity already has cache:", key))
        cls._caches[key] = lrucache(size)