def serve_request(self, path):
     """Given an URL path, return response.
     """
     request = Request(uri=path)
     request.website = self
     response = self.handle_safely(request)
     return response

 def load_simplate(self, path, request=None, return_request_too=False):
     """Given an URL path, return a simplate (Resource) object.
     """
     if request is None:
         request = Request(uri=path)
     if not hasattr(request, 'website'):
         request.website = self
     self.do_inbound(request)
     resource = resources.get(request)
     if return_request_too:
         return resource, request
     else:
         return resource

 def get_request(self, path, method="GET", body=None, **extra):
     env = StubWSGIRequest(path)
     env["REQUEST_METHOD"] = method
     env["wsgi.input"] = StringIO(body)
     env["HTTP_COOKIE"] = self.cookies.output(header="", sep="; ")
     env.update(extra)
     return Request.from_wsgi(env)

 def get_request(self, path, method="GET", body=None,
                 **extra):
     env = StubWSGIRequest(path)
     env['REQUEST_METHOD'] = method
     env['wsgi.input'] = StringIO(body)
     env['HTTP_COOKIE'] = self.cookies.output(header='', sep='; ')
     env.update(extra)
     return Request.from_wsgi(env)

 def __call__(self, environ, start_response):
     """WSGI interface.
     """
     request = Request.from_wsgi(environ) # too big to fail :-/
     response = self.handle_safely(request)
     response.request = request # Stick this on here at the last minute
                                # in order to support close hooks.
     return response(environ, start_response)

 def get_request(self, path, method="GET", body=None,
                 **extra):
     env = StubWSGIRequest(path.encode('utf8'))
     env[b'REQUEST_METHOD'] = method.encode('utf8')
     env[b'wsgi.input'] = StringIO(body)
     env[b'HTTP_COOKIE'] = self.cookies.output(header='', sep='; ').encode('utf8')
     for k,v in extra.items():
         env[k.encode('utf8')] = v.encode('utf8')
     return Request.from_wsgi(env)

 def from_fs(cls, fs):
     """Takes a path under ./fsfix using / as the path separator.
     """
     fs = os.sep.join(fs.split('/'))
     request = Request.from_wsgi(StubWSGIRequest(fs))
     c = Configurable.from_argv(['fsfix'])
     c.copy_configuration_to(request)
     request.fs = fs
     request.namespace = {}
     request.website = Stub()
     request.website.template_loader = Stub()
     return request

 def from_fs(cls, fs):
     """Takes a path under ./fsfix using / as the path separator.
     """
     fs = os.sep.join(fs.split(os.sep))
     request = Request.from_wsgi(StubWSGIRequest(fs))
     website = Configurable.from_argv(['--root', 'fsfix'])
     website.copy_configuration_to(request)
     request.root = join(dirname(__file__), 'fsfix')
     request.fs = fs
     request.namespace = {}
     request.website = website 
     request.website.template_loader = Stub()
     return request

 def from_fs(cls, fs, *a):
     """Takes a path under FSFIX using / as the path separator.
     """
     fs = os.sep.join(fs.split(os.sep))
     request = Request.from_wsgi(StubWSGIRequest(fs))
     website = Configurable.from_argv([ '--www_root', FSFIX
                                      , '--project_root', '.aspen'
                                       ] + list(a))
     request.www_root = os.path.join(os.path.dirname(__file__), FSFIX)
     request.fs = fs
     request.context = {}
     request.website = website 
     request._media_type = None
     return request

    def wsgi_app(self, environ, start_response):
        """WSGI interface.

        Wrap this method instead of the website object itself
        when to use WSGI middleware::

            website = Website()
            website.wsgi_app = WSGIMiddleware(website.wsgi_app)

        """
        request = Request.from_wsgi(environ) # too big to fail :-/
        request.website = self
        response = self.handle_safely(request)
        response.request = request # Stick this on here at the last minute
                                   # in order to support close hooks.
        return response(environ, start_response)

 def from_fs(cls, fs, *a):
     """Takes a path under FSFIX using / as the path separator.
     """
     fs = os.sep.join(fs.split(os.sep))
     uri_path = fs
     if fs.endswith('.spt'):
         uri_path = fs[:-4]
     request = Request.from_wsgi(StubWSGIRequest(uri_path))
     website = Website([ '--www_root', FSFIX
                       , '--project_root', os.path.join(FSFIX, '.aspen')
                        ] + list(a))
     request.www_root = os.path.join(os.path.dirname(__file__), FSFIX)
     request.fs = fs
     request.context = {}
     request.website = website
     request._media_type = None
     return request

def parse_environ_into_request(environ):
    return {'request': Request.from_wsgi(environ)}

 def __call__(self, environ, start_response):
     """WSGI interface.
     """
     request = Request.from_wsgi(environ) # too big to fail :-/
     response = self.handle(request)
     return response(environ, start_response)

 def __call__(cls, uripath=b'/'):
     typecheck(uripath, str)
     return Request.from_wsgi(StubWSGIRequest(uripath))

def make_request(filename='echo.sock'):
    request = Request(url='/echo.sock')
    request.website = Website([])
    request.website.copy_configuration_to(request)
    request.fs = fix(filename)
    return request

def make_request():
    return Request.from_diesel(DieselReq())

def make_request(filename='echo.sock'):
    request = Request(uri='/echo.sock')
    request.website = Website([])
    request.fs = fix(filename)
    return request

def handle(path):
    website = Website(Configuration(['fsfix']))
    return website.handle(Request.from_diesel(DieselReq(path)))

def get_simplate_context(website, fs):
    request = Request()
    request.fs = fs
    request.website = website
    resource = resources.get(request)
    return {} if isinstance(resource, StaticResource) else resource.pages[0]

 def __call__(self, diesel_request):
     """Given a Diesel request, return a Diesel response.
     """
     request = Request.from_diesel(diesel_request) # too big to fail :-/
     response = self.handle(request)
     return response._to_diesel(diesel_request) # sends bits, returns bool