A Unix-style Python web framework: filesystem routing, flat files, messages and cron, with CGI's simplicity at modern speed.

0 downloads

Download zip
Clone
Clone with git
git clone https://gitstable.com/git/askrobots/dbbasic-web.git
HTTPS
https://gitstable.com/git/askrobots/dbbasic-web.git
SSH
ssh://git@gitstable.com:2222/askrobots/dbbasic-web.git

Cloning needs no sign-in. Pushing over HTTPS asks for your username and an access token. SSH needs your key under SSH keys.

Dan Quellhorst Replace multipart parser with stdlib-only implementation eb957a2 9 months, 2 weeks ago History
request.py · 5.2 KB · 177 lines
1"""Request object with convenient property access"""
2
3
4class Request(dict):
5 """
6 Enhanced request dict with convenient property access.
7
8 Backward compatible with dict access while providing cleaner syntax:
9 request['method'] -> request.method
10 request['form'] -> request.POST
11 request['query'] -> request.GET
12 request['cookies'] -> request.COOKIES
13
14 Philosophy: PHP-style explicit data sources (no magic merging)
15 Plus: Perl-style convenience with param() method
16 """
17
18 @property
19 def method(self) -> str:
20 """HTTP method: GET, POST, PUT, DELETE, etc."""
21 return self.get('method', 'GET')
22
23 @property
24 def POST(self) -> dict:
25 """Form data from POST body (application/x-www-form-urlencoded)"""
26 return self.get('form', {})
27
28 @property
29 def GET(self) -> dict:
30 """Query string parameters from URL"""
31 return self.get('query', {})
32
33 @property
34 def COOKIES(self) -> dict:
35 """Cookies from Cookie header"""
36 return self.get('cookies', {})
37
38 @property
39 def PATH(self) -> list:
40 """Path segments as list. Example: /profile/alice -> ['profile', 'alice']"""
41 return self.get('path_parts', [])
42
43 @property
44 def body(self) -> bytes:
45 """Raw request body as bytes"""
46 return self.get('body', b'')
47
48 @property
49 def files(self) -> dict:
50 """
51 Uploaded files from multipart/form-data requests.
52
53 Returns a dict mapping field names to file info dicts:
54 {
55 'fieldname': {
56 'filename': 'original_filename.jpg',
57 'content': b'...file bytes...',
58 'content_type': 'image/jpeg'
59 }
60 }
61
62 Example:
63 uploaded = request.files.get('avatar')
64 if uploaded:
65 filename = uploaded['filename']
66 content = uploaded['content']
67 # Save file, process, etc.
68 """
69 return self.get('files', {})
70
71 @property
72 def path(self) -> str:
73 """Full request path"""
74 return self.get('path', '/')
75
76 def param(self, key: str, default=None):
77 """
78 Get parameter from POST form data first, then GET query string.
79
80 Perl CGI.pm-style convenience method. Explicit lookup order:
81 1. POST form data (request.POST)
82 2. GET query string (request.GET)
83
84 Example:
85 email = request.param('email') # Checks POST, then GET
86 page = request.param('page', '1') # With default
87
88 This is explicit and documented - not magic!
89 """
90 # Check POST first (form data)
91 if key in self.POST:
92 return self.POST[key]
93
94 # Then check GET (query string)
95 if key in self.GET:
96 return self.GET[key]
97
98 # Return default if not found
99 return default
100
101 def cookie(self, key: str, default=None):
102 """
103 Get cookie value.
104
105 Example:
106 session = request.cookie('session')
107 """
108 return self.COOKIES.get(key, default)
109
110 def path_param(self, index: int, default=None):
111 """
112 Get path parameter by index.
113
114 Example:
115 # Request: /profile/alice
116 username = request.path_param(1) # Returns 'alice'
117
118 # Request: /posts/123/edit
119 post_id = request.path_param(1) # Returns '123'
120 action = request.path_param(2) # Returns 'edit'
121 """
122 parts = self.PATH
123 return parts[index] if len(parts) > index else default
124
125 def require_auth(self, accounts, redirect_to='/login'):
126 """
127 Get authenticated user or return redirect response.
128
129 Reduces 10-line authentication pattern to 2 lines:
130
131 Before:
132 token = request.cookie('session')
133 if not token:
134 return redirect('/login')
135 user_id = get_session(token)
136 if not user_id:
137 return redirect('/login')
138 user = accounts.get_user(user_id=int(user_id))
139 if not user:
140 return redirect('/login')
141
142 After:
143 user, auth_error = request.require_auth(accounts)
144 if auth_error:
145 return auth_error
146
147 Returns:
148 tuple: (user, None) if authenticated, (None, redirect_response) if not
149
150 Example:
151 from dbbasic.accounts import Accounts
152 accounts = Accounts()
153
154 def handle(request):
155 user, auth_error = request.require_auth(accounts)
156 if auth_error:
157 return auth_error
158
159 # Now we have authenticated user
160 return html(f"Hello {user.name}")
161 """
162 from dbbasic_sessions import get_session
163 from dbbasic_web.responses import redirect
164
165 token = self.cookie('session')
166 if not token:
167 return None, redirect(redirect_to)
168
169 user_id = get_session(token)
170 if not user_id:
171 return None, redirect(redirect_to)
172
173 user = accounts.get_user(user_id=int(user_id))
174 if not user:
175 return None, redirect(redirect_to)
176
177 return user, None