text: #!/usr/bin/env python
  # -*- coding: utf-8 -*-
  #-----------------------
  # Name: cache_engine.py
  # Python Library
  # Author: Raymond Wagner
  # Purpose: Base cache engine class for collecting registered engines
  #-----------------------
  
  import time
  from weakref import ref
  
  class Engines( object ):
      def __init__(self):
          self._engines = {}
      def register(self, engine):
          self._engines[engine.__name__] = engine
          self._engines[engine.name] = engine
      def __getitem__(self, key):
          return self._engines[key]
      def __contains__(self, key):
          return self._engines.__contains__(key)
  Engines = Engines()
  
  class CacheEngineType( type ):
      """
      Cache Engine Metaclass that registers new engines against the cache
      for named selection and use.
      """
      def __init__(mcs, name, bases, attrs):
          super(CacheEngineType, mcs).__init__(name, bases, attrs)
          if name != 'CacheEngine':
              # skip base class
              Engines.register(mcs)
  
  class CacheEngine( object ):
      __metaclass__ = CacheEngineType
  
      name = 'unspecified'
      def __init__(self, parent):
          self.parent = ref(parent)
      def configure(self):
          raise RuntimeError
      def get(self, date):
          raise RuntimeError
      def put(self, key, value, lifetime):
          raise RuntimeError
      def expire(self, key):
          raise RuntimeError
  
  class CacheObject( object ):
      """
      Cache object class, containing one stored record.
      """
  
      def __init__(self, key, data, lifetime=0, creation=None):
          self.key = key
          self.data = data
          self.lifetime = lifetime
          self.creation = creation if creation is not None else time.time()
  
      def __len__(self):
          return len(self.data)
  
      @property
      def expired(self):
          return (self.remaining == 0)
  
      @property
      def remaining(self):
          return max((self.creation + self.lifetime) - time.time(), 0)
  
  