def initialize(self, **kwargs):
     if 'no_cache' in kwargs:
         self._no_cache = kwargs['no_cache']
         del kwargs['no_cache']
     else:
         self._no_cache = False
     StaticFileHandler.initialize(self, **kwargs)

 def get_content(cls, abspath, start=None, end=None):
     if cls.is_html_path(abspath):
         html = open(abspath, 'r').read()
         html = html.replace('</body>', cls.SCRIPT_AND_END_OF_BODY)
         return html
     else:
         return StaticFileHandler.get_content(abspath, start, end)

 def get_content_size(self):
     _, ext = os.path.splitext(self.absolute_path)
     if ext in SPECIAL_EXTENSIONS:
         content = self.__class__.get_content(self.absolute_path)
         return len(content)
     else:
         return StaticFileHandler.get_content_size(self)

    def __init__(self):
        self.db = pymongo.Connection(port=settings.DB_PORT)[settings.DB_NAME]
        self.fs = GridFS(self.db)
        self.loader = Loader(
            os.path.join(ROOT_DIR, 'template'),
            autoescape=None,
            namespace={
                'static_url': lambda url: StaticFileHandler.make_static_url({'static_path': STATIC_DIR}, url),
                '_modules': ObjectDict({'Template': lambda template, **kwargs: self.loader.load(template).generate(**kwargs)}),
            },
        )

        router = TornadioRouter(ScribeConnection)
        router.app = self
        socketio = TornadoApplication(router.urls, app=self)
        self.connections = []

        class FooResource(Resource):
            def __call__(self, request):
                socketio(request)

            def __getitem__(self, name):
                return self

        Application.__init__(self, {
            '': HomeResource(self),
            'favicon.ico': StaticFileResource(os.path.join(STATIC_DIR, 'img', 'favicon.ico')),
            'sounds': EditsResource(self),
            'static': StaticFileResource(STATIC_DIR),
            'socket.io': FooResource(),
        })

 def get(self, group, path):
     logging.info("Request for %s file %s" % (group, path))
     
     #check that requested file directory is in defined archives - note that group does not have the leading \ or / characters
     if os.path.normpath(group).startswith(self.portal_rel_path):
         self.root = self.portal_abs_path + os.path.sep
         group = relativePath(group[len(self.portal_rel_path):])
     elif os.path.normpath(group).startswith(self.report_rel_path):
         self.root = self.report_abs_path + os.path.sep
         group = relativePath(group[len(self.report_rel_path):])
     else:
         raise HTTPError(404, "Invalid file %s" % path)
     
     path = os.path.join(group, path)
     #disable caching or archive files
     self.set_header("Cache-control", "no-cache")        
     StaticFileHandler.get(self, path, include_body=True)

 def append_version(cls, path):
     # this version is cached on the StaticFileHandler class,
     # keyed by absolute filesystem path, and only invalidated
     # on an explicit StaticFileHandler.reset(). The reset is
     # automatic on every request if you set
     # static_hash_cache=False in TornadoApplication kwargs.
     version = StaticFileHandler.get_version(dict(static_path=settings.bokehjsdir()), path)
     return ("%s?v=%s" % (path, version))

 def get_content(cls, abspath, start=None, end=None):
     gc.collect()  # 在mp4内容的时候，如果刷新网页会导致10053错误，并且内存不能回收，这里粗暴处理一下
     if cls.is_html_path(abspath):
         html = open(abspath, 'r').read()
         html = html.replace('</body>', cls.SCRIPT_AND_END_OF_BODY)
         return html
     else:
         return StaticFileHandler.get_content(abspath, start, end)

 def get_content(cls, abspath, start=None, end=None):
     gc.collect()  # 在mp4内容的时候，如果刷新网页会导致10053错误，并且内存不能回收，这里粗暴处理一下
     _, ext = os.path.splitext(abspath)
     if ext in SPECIAL_EXTENSIONS:
         content = open(abspath, 'r').read()
         if ext in HTML_EXTENSIONS:
             return process_html(content)
         elif ext in CSS_EXTENSIONS:
             return process_css(content)
     return StaticFileHandler.get_content(abspath, start, end)

 def append_version(cls, path):
     # This version is cached on the StaticFileHandler class,
     # keyed by absolute filesystem path, and only invalidated
     # on an explicit StaticFileHandler.reset(). The reset is
     # automatic on every request if you set static_hash_cache=False
     # in TornadoApplication kwargs. In dev mode rely on dev tools
     # to manage caching. This improves the ability to debug code.
     if settings.dev:
         return path
     else:
         version = StaticFileHandler.get_version(dict(static_path=settings.bokehjsdir()), path)
         return ("%s?v=%s" % (path, version))

    def initialize(self):
        # return custom type directly. The browser will do the parsing
        self.custom_type = None

        uri = self.get_argument('uri')

        try:
            self.modgui = get_plugin_gui(uri)
        except:
            raise HTTPError(404)

        try:
            root = self.modgui['resourcesDirectory']
        except:
            raise HTTPError(404)

        return StaticFileHandler.initialize(self, root)

 def initialize(self):
     StaticFileHandler.initialize(self, os.path.join(os.path.dirname(__file__), "data"))

 def get_absolute_path(cls, root, path):
     return StaticFileHandler.get_absolute_path(root, "")

    def parse_url_path(self, url_path):
        if not url_path or url_path.endswith('/'):
            url_path += 'index.html'

        return StaticFileHandler.parse_url_path(self, url_path)

 def initialize(self, path, default_filename=None, as_attachment=False):
     StaticFileHandler.initialize(self, path, default_filename)
     self._as_attachment = as_attachment

 def get(self):
     StaticFileHandler.get(self, 'sitemap.xml')

 def static_handler(self, path):
     handler = StaticFileHandler(self.application, self.request, path=STATIC_PATH)
     transforms = [t(self.request) for t in self.application.transforms]
     yield handler._execute(transforms, path)

 def initialize(self, path, default_filename=None, others=None):
     StaticFileHandler.initialize(self, path, default_filename)
     self._others = others if others else self.application.settings["static_handler_args"]["others"]

	def initialize(self):
		StaticFileHandler.initialize(self, 
			self.controllers[Resource].styles_file_dir)

 def make_static_url(self, path):
     return StaticFileHandler.make_static_url(self.conf,
                                              path)

 def initialize(self):
     StaticFileHandler.initialize(self, UPLOAD_PATH)