askrobots / dbbasic-web
Public
A Unix-style Python web framework: filesystem routing, flat files, messages and cron, with CGI's simplicity at modern speed.
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 | |
| 4 | class 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 |