File Manager

Hackfut Security File Manager

Current Path: /usr/lib64/python2.6/site-packages/Cheetah

usr / lib64 / python2.6 / site-packages / Cheetah /

📁 ..
📄 CacheRegion.py(4.32 KB)
📄 CacheRegion.pyc(6.48 KB)
📄 CacheRegion.pyo(6.44 KB)
📄 CacheStore.py(2.98 KB)
📄 CacheStore.pyc(5.74 KB)
📄 CacheStore.pyo(5.74 KB)
📄 CheetahWrapper.py(23.33 KB)
📄 CheetahWrapper.pyc(22.42 KB)
📄 CheetahWrapper.pyo(22.36 KB)
📄 Compiler.py(78.4 KB)
📄 Compiler.pyc(74.96 KB)
📄 Compiler.pyo(74.88 KB)
📄 DirectiveAnalyzer.py(2.39 KB)
📄 DirectiveAnalyzer.pyc(3.95 KB)
📄 DirectiveAnalyzer.pyo(3.95 KB)
📄 Django.py(592 B)
📄 Django.pyc(945 B)
📄 Django.pyo(945 B)
📄 DummyTransaction.py(3.2 KB)
📄 DummyTransaction.pyc(5.54 KB)
📄 DummyTransaction.pyo(5.54 KB)
📄 ErrorCatchers.py(1.71 KB)
📄 ErrorCatchers.pyc(3.53 KB)
📄 ErrorCatchers.pyo(3.53 KB)
📄 FileUtils.py(10.41 KB)
📄 FileUtils.pyc(13.14 KB)
📄 FileUtils.pyo(13.14 KB)
📄 Filters.py(7.46 KB)
📄 Filters.pyc(8.47 KB)
📄 Filters.pyo(8.47 KB)
📄 ImportHooks.py(4.37 KB)
📄 ImportHooks.pyc(4.27 KB)
📄 ImportHooks.pyo(4.27 KB)
📄 ImportManager.py(17.14 KB)
📄 ImportManager.pyc(16.88 KB)
📄 ImportManager.pyo(16.88 KB)
📁 Macros
📄 NameMapper.py(12.79 KB)
📄 NameMapper.pyc(13.83 KB)
📄 NameMapper.pyo(13.83 KB)
📄 Parser.py(101.17 KB)
📄 Parser.pyc(79.56 KB)
📄 Parser.pyo(79.37 KB)
📄 Servlet.py(3.33 KB)
📄 Servlet.pyc(3.79 KB)
📄 Servlet.pyo(3.79 KB)
📄 SettingsManager.py(10.12 KB)
📄 SettingsManager.pyc(11.53 KB)
📄 SettingsManager.pyo(11.53 KB)
📄 SourceReader.py(8.85 KB)
📄 SourceReader.pyc(11.68 KB)
📄 SourceReader.pyo(11.68 KB)
📄 Template.py(82.76 KB)
📄 Template.pyc(66.8 KB)
📄 Template.pyo(66.72 KB)
📄 TemplateCmdLineIface.py(3.23 KB)
📄 TemplateCmdLineIface.pyc(3.89 KB)
📄 TemplateCmdLineIface.pyo(3.89 KB)
📁 Templates
📁 Tests
📁 Tools
📄 Unspecified.py(258 B)
📄 Unspecified.pyc(809 B)
📄 Unspecified.pyo(809 B)
📁 Utils
📄 Version.py(1.5 KB)
📄 Version.pyc(1.82 KB)
📄 Version.pyo(1.27 KB)
📄 __init__.py(582 B)
📄 __init__.pyc(756 B)
📄 __init__.pyo(756 B)
📄 _namemapper.so(13.26 KB)
📄 convertTmplPathToModuleName.py(496 B)
📄 convertTmplPathToModuleName.pyc(706 B)
📄 convertTmplPathToModuleName.pyo(706 B)

Editing: CacheRegion.py

# $Id: CacheRegion.py,v 1.3 2006/01/28 04:19:30 tavis_rudd Exp $
'''
Cache holder classes for Cheetah:

Cache regions are defined using the #cache Cheetah directive. Each
cache region can be viewed as a dictionary (keyed by cacheRegionID)
handling at least one cache item (the default one). It's possible to add
cacheItems in a region by using the `varyBy` #cache directive parameter as
in the following example::
   #def getArticle
      this is the article content.
   #end def

#cache varyBy=$getArticleID()
      $getArticle($getArticleID())
   #end cache

The code above will generate a CacheRegion and add new cacheItem for each value
of $getArticleID().
'''

try:
    from hashlib import md5
except ImportError:
    from md5 import md5

import time
import Cheetah.CacheStore

class CacheItem(object):
    '''
    A CacheItem is a container storing:

- cacheID (string)
        - refreshTime (timestamp or None) : last time the cache was refreshed
        - data (string) : the content of the cache
    '''
    
    def __init__(self, cacheItemID, cacheStore):
        self._cacheItemID = cacheItemID
        self._cacheStore = cacheStore
        self._refreshTime = None
        self._expiryTime = 0

def hasExpired(self):
        return (self._expiryTime and time.time() > self._expiryTime)
    
    def setExpiryTime(self, time):
        self._expiryTime = time

def getExpiryTime(self):
        return self._expiryTime

def setData(self, data):
        self._refreshTime = time.time()
        self._cacheStore.set(self._cacheItemID, data, self._expiryTime)

def getRefreshTime(self):
        return self._refreshTime

def getData(self):
        assert self._refreshTime
        return self._cacheStore.get(self._cacheItemID)

def renderOutput(self):
        """Can be overridden to implement edge-caching"""
        return self.getData() or ""

def clear(self):
        self._cacheStore.delete(self._cacheItemID)
        self._refreshTime = None

class _CacheDataStoreWrapper(object):
    def __init__(self, dataStore, keyPrefix):
        self._dataStore = dataStore
        self._keyPrefix = keyPrefix
        
    def get(self, key):
        return self._dataStore.get(self._keyPrefix+key)

def delete(self, key):
        self._dataStore.delete(self._keyPrefix+key)

def set(self, key, val, time=0):        
        self._dataStore.set(self._keyPrefix+key, val, time=time)

class CacheRegion(object):
    '''
    A `CacheRegion` stores some `CacheItem` instances.

This implementation stores the data in the memory of the current process.
    If you need a more advanced data store, create a cacheStore class that works
    with Cheetah's CacheStore protocol and provide it as the cacheStore argument
    to __init__.  For example you could use
    Cheetah.CacheStore.MemcachedCacheStore, a wrapper around the Python
    memcached API (http://www.danga.com/memcached).
    '''
    _cacheItemClass = CacheItem
    
    def __init__(self, regionID, templateCacheIdPrefix='', cacheStore=None):
        self._isNew = True
        self._regionID = regionID
        self._templateCacheIdPrefix = templateCacheIdPrefix
        if not cacheStore:
            cacheStore = Cheetah.CacheStore.MemoryCacheStore()
        self._cacheStore = cacheStore
        self._wrappedCacheDataStore = _CacheDataStoreWrapper(
            cacheStore, keyPrefix=templateCacheIdPrefix+':'+regionID+':')
        self._cacheItems = {}

def isNew(self):
        return self._isNew
        
    def clear(self):
        " drop all the caches stored in this cache region "
        for cacheItemId in self._cacheItems.keys():
            cacheItem = self._cacheItems[cacheItemId]
            cacheItem.clear()
            del self._cacheItems[cacheItemId]
        
    def getCacheItem(self, cacheItemID):
        """ Lazy access to a cacheItem

Try to find a cache in the stored caches. If it doesn't
            exist, it's created.
            
            Returns a `CacheItem` instance.
        """
        cacheItemID = md5(str(cacheItemID)).hexdigest()
        
        if cacheItemID not in self._cacheItems:
            cacheItem = self._cacheItemClass(
                cacheItemID=cacheItemID, cacheStore=self._wrappedCacheDataStore)
            self._cacheItems[cacheItemID] = cacheItem
            self._isNew = False
        return self._cacheItems[cacheItemID]

Hackfut Security File Manager

Editing: CacheRegion.py

Upload File

Create Folder