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

    25

    def lookup (self, request):

    26

        """

    27

            Lookup Request -> Handler, params

    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)

    38

    39

        return handler, params

    40

    41

    def respond (self, request):

    42

        """

    43

            Process Request -> Response, using lookup()

    44

        """

    45

    46

        handler, params = self.lookup(request)

    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

    94

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

    95

        """

    96

            Return an URL for given endpoint, with parameters,

    97

        """

    98

    99

        if not handler :

   100

            handler = self.__class__

   101

   102

        return self.urls.build(handler, params)

   103

   104

    ## processing stages

   105

    def init (self) :

   106

        """

   107

            Initialize on request start.

   108

        """

   109

   110

        pass

   111

   112

    def process (self, **params) :

   113

        """

   114

            Process request args to build internal request state.

   115

   116

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

   117

        """

   118

   119

        pass

   120

   121

    def render (self) :

   122

        """

   123

            Render response.

   124

        """

   125

   126

        raise NotImplementedError()

   127

   128

    def status (self):

   129

        return 200

   130

   131

    def headers (self):

   132

        return [ ]

   133

   134

    def mimetype (self):

   135

        return self.MIMETYPE

   136

   137

   138

    def respond (self, **params) :

   139

        """

   140

            Generate a response, or raise an HTTPException

   141

        """

   142

   143

        # returning e.g. redirect?

   144

        response = self.process(**params)

   145

   146

        if response :

   147

            return response

   148

   149

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

   150

   151

    def cleanup (self) :

   152

        """

   153

            After request processing. Do not fail :)

   154

        """

   155

   156

        pass

   157