werkzeug

1
from os import path
2
from random import randrange
3
from random import sample
4
from urllib.parse import urlsplit
5

6
from jinja2 import Environment
7
from jinja2 import FileSystemLoader
8
from werkzeug.local import Local
9
from werkzeug.local import LocalManager
10
from werkzeug.routing import Map
11
from werkzeug.routing import Rule
12
from werkzeug.utils import cached_property
13
from werkzeug.wrappers import Response
14

15
TEMPLATE_PATH = path.join(path.dirname(__file__), "templates")
16
STATIC_PATH = path.join(path.dirname(__file__), "static")
17
ALLOWED_SCHEMES = frozenset(["http", "https", "ftp", "ftps"])
18
URL_CHARS = "abcdefghijkmpqrstuvwxyzABCDEFGHIJKLMNPQRST23456789"
19

20
local = Local()
21
local_manager = LocalManager([local])
22
application = local("application")
23

24
url_map = Map([Rule("/static/<file>", endpoint="static", build_only=True)])
25

26
jinja_env = Environment(loader=FileSystemLoader(TEMPLATE_PATH))
27

28

29
def expose(rule, **kw):
30
    def decorate(f):
31
        kw["endpoint"] = f.__name__
32
        url_map.add(Rule(rule, **kw))
33
        return f
34

35
    return decorate
36

37

38
def url_for(endpoint, _external=False, **values):
39
    return local.url_adapter.build(endpoint, values, force_external=_external)
40

41

42
jinja_env.globals["url_for"] = url_for
43

44

45
def render_template(template, **context):
46
    return Response(
47
        jinja_env.get_template(template).render(**context), mimetype="text/html"
48
    )
49

50

51
def validate_url(url):
52
    return urlsplit(url)[0] in ALLOWED_SCHEMES
53

54

55
def get_random_uid():
56
    return "".join(sample(URL_CHARS, randrange(3, 9)))
57

58

59
class Pagination:
60
    def __init__(self, results, per_page, page, endpoint):
61
        self.results = results
62
        self.per_page = per_page
63
        self.page = page
64
        self.endpoint = endpoint
65

66
    @cached_property
67
    def count(self):
68
        return len(self.results)
69

70
    @cached_property
71
    def entries(self):
72
        return self.results[
73
            ((self.page - 1) * self.per_page) : (
74
                ((self.page - 1) * self.per_page) + self.per_page
75
            )
76
        ]
77

78
    @property
79
    def has_previous(self):
80
        """Return True if there are pages before the current one."""
81
        return self.page > 1
82

83
    @property
84
    def has_next(self):
85
        """Return True if there are pages after the current one."""
86
        return self.page < self.pages
87

88
    @property
89
    def previous(self):
90
        """Return the URL for the previous page."""
91
        return url_for(self.endpoint, page=self.page - 1)
92

93
    @property
94
    def next(self):
95
        """Return the URL for the next page."""
96
        return url_for(self.endpoint, page=self.page + 1)
97

98
    @property
99
    def pages(self):
100
        """Return the number of pages."""
101
        return max(0, self.count - 1) // self.per_page + 1
102