1

from werkzeug.wrappers import Request, Response

     2

from werkzeug.exceptions import (

     3

        HTTPException,

     4

        BadRequest,         # 400

     5

        NotFound,           # 404

     6

)

     7

from werkzeug.utils import redirect

     8

     9

class Application:

    10

    URLS = None

    11

    12

    def __init__ (self, urls=None):

    13

        """

    14

            urls        - werkzeug.routing.Map -> Handler

    15

        """

    16

    17

        if not urls:

    18

            urls = self.URLS

    19

    20

        if not urls:

    21

            raise ValueError("Required URLS/urls=...")

    22

    23

        self.urls = urls

    24

    26

        """

    28

        """

    29

    30

        # bind to request

    31

        urls = self.urls.bind_to_environ(request)

    32

    33

        # lookup

    34

        handler, params = urls.match()

    35

    36

        # handler instance

    37

        handler = handler(self, request, urls)

    47

    48

        try :

    49

            handler.init()

    50

    51

            # apply

    52

            return handler.respond(**params)

    53

    54

        finally :

    55

            handler.cleanup()

    56

    57

    @Request.application

    58

    def __call__ (self, request) :

    59

        """

    60

            WSGI entry point, werkzeug Request -> Response

    61

        """

    62

    63

        try :

    64

            return self.respond(request)

    65

    66

        except HTTPException as ex :

    67

            return ex

    68

    69

class Handler (object) :

    70

    """

    71

        Per-Request controller/view, containing the request context and generating the response.

    72

    """

    73

    74

    # werkzeug defaults to UTF-8

    75

    MIMETYPE = 'text/html'

    76

    77

    def __init__ (self, app, request, urls) :

    78

        """

    79

            app     - wsgi.Application

    80

            request - werkzeug.Request

    81

            urls    - werkzeug.routing.Map.bind_to_environ()

    82

        """

    83

    84

        self.app = app

    85

        self.request = request

    86

        self.urls = urls

    87

    88

    def url (self, handler=None, **params) :

    89

        """

    90

            Return an URL for given endpoint, with parameters,

    91

        """

    92

    93

        if not handler :

    94

            handler = self.__class__

    95

    96

        return self.urls.build(handler, params)

    97

    98

    ## processing stages

    99

    def init (self) :

   100

        """

   101

            Initialize on request start.

   102

        """

   103

   104

        pass

   105

   106

    def process (self, **params) :

   107

        """

   108

            Process request args to build internal request state.

   109

   110

            May optionally return a Response, to e.g. redirect after POST.

   111

        """

   112

   113

        pass

   114

   115

    def render (self) :

   116

        """

   117

            Render response.

   118

        """

   119

   120

        raise NotImplementedError()

   121

   122

    def mimetype (self):

   123

        return self.MIMETYPE

   124

   125

    def status (self):

   126

        return 200

   127

   128

    def respond (self, **params) :

   129

        """

   130

            Generate a response, or raise an HTTPException

   131

        """

   132

   133

        # returning e.g. redirect?

   134

        response = self.process(**params)

   135

   136

        if response :

   137

            return response

   138

   139

        return Response(self.render_response(), mimetype=self.mimetype(), status=self.status())

   141

    def cleanup (self) :

   142

        """

   143

            After request processing. Do not fail :)

   144

        """

   145

   146

        pass

   147