askrobots / dbbasic Public

Model-config web apps: describe the app in configuration instead of writing code. Built on Polars and DuckDB.

0 downloads

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

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

danq9 Add DBBasic crate engine logo and update README 0d628db 1 year, 2 months ago History
tailwind_components.py · 17.5 KB · 478 lines
1#!/usr/bin/env python3
2"""
3Tailwind CSS Renderer for Presentation Layer
4Provides Tailwind CSS 3.x component rendering
5"""
6
7from typing import Dict, List, Any, Optional
8from presentation_layer import UIRenderer
9
10class TailwindRenderer(UIRenderer):
11 """Tailwind CSS renderer implementation"""
12
13 def render_page(self, data: Dict) -> str:
14 """Render a complete page with Tailwind CSS"""
15 title = data.get('title', 'DBBasic')
16 components = data.get('components', [])
17
18 # Render all components
19 body_content = ''.join([self.render(comp) for comp in components])
20
21 return f'''<!DOCTYPE html>
22<html lang="en" class="h-full">
23<head>
24 <meta charset="UTF-8">
25 <meta name="viewport" content="width=device-width, initial-scale=1.0">
26 <title>{title}</title>
27 <script src="https://cdn.tailwindcss.com"></script>
28 <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css">
29</head>
30<body class="h-full bg-gray-50">
31 {body_content}
32</body>
33</html>'''
34
35 def render_navbar(self, data: Dict) -> str:
36 """Render Tailwind navigation bar"""
37 brand = data.get('brand', 'DBBasic')
38 links = data.get('links', [])
39 variant = data.get('variant', 'light')
40
41 # Tailwind navbar classes
42 nav_class = 'bg-white shadow' if variant == 'light' else 'bg-gray-900'
43 text_class = 'text-gray-900' if variant == 'light' else 'text-white'
44 link_class = 'text-gray-700 hover:text-indigo-600' if variant == 'light' else 'text-gray-300 hover:text-white'
45
46 links_html = ''.join([
47 f'<a href="{link.get("url", "#")}" class="{link_class} px-3 py-2 rounded-md text-sm font-medium">{link.get("text", "")}</a>'
48 for link in links
49 ])
50
51 return f'''
52 <nav class="{nav_class}">
53 <div class="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8">
54 <div class="flex justify-between h-16">
55 <div class="flex">
56 <div class="flex-shrink-0 flex items-center">
57 <h1 class="{text_class} text-2xl font-bold">{brand}</h1>
58 </div>
59 <div class="hidden sm:ml-6 sm:flex sm:space-x-8">
60 {links_html}
61 </div>
62 </div>
63 </div>
64 </div>
65 </nav>
66 '''
67
68 def render_hero(self, data: Dict) -> str:
69 """Render Tailwind hero section"""
70 title = data.get('title', '')
71 subtitle = data.get('subtitle', '')
72 variant = data.get('variant', 'default')
73
74 # Gradient backgrounds
75 bg_class = {
76 'default': 'bg-white',
77 'gradient-blue': 'bg-gradient-to-r from-blue-600 to-indigo-600',
78 'gradient-purple': 'bg-gradient-to-r from-purple-600 to-pink-600',
79 'gradient-green': 'bg-gradient-to-r from-green-600 to-teal-600'
80 }.get(variant, 'bg-white')
81
82 text_color = 'text-white' if 'gradient' in variant else 'text-gray-900'
83
84 return f'''
85 <div class="{bg_class} py-16">
86 <div class="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8">
87 <div class="text-center">
88 <h1 class="{text_color} text-4xl font-bold sm:text-5xl md:text-6xl">
89 {title}
90 </h1>
91 <p class="{text_color} mt-3 max-w-2xl mx-auto text-xl sm:mt-4">
92 {subtitle}
93 </p>
94 </div>
95 </div>
96 </div>
97 '''
98
99 def render_card(self, data: Dict) -> str:
100 """Render Tailwind card component"""
101 title = data.get('title', '')
102 description = data.get('description', '')
103 body = data.get('body', '')
104 footer = data.get('footer', '')
105
106 # Process body content
107 if isinstance(body, dict):
108 body_html = self.render(body)
109 elif isinstance(body, list):
110 body_html = ''.join([self.render(item) for item in body])
111 else:
112 body_html = str(body)
113
114 # Footer content
115 footer_html = ''
116 if footer:
117 if isinstance(footer, dict):
118 footer_html = f'<div class="px-6 py-4 bg-gray-50 border-t">{self.render(footer)}</div>'
119 else:
120 footer_html = f'<div class="px-6 py-4 bg-gray-50 border-t">{footer}</div>'
121
122 return f'''
123 <div class="bg-white overflow-hidden shadow rounded-lg">
124 {f'<div class="px-6 py-4 border-b"><h3 class="text-lg font-medium text-gray-900">{title}</h3></div>' if title else ''}
125 <div class="px-6 py-4">
126 {f'<p class="text-gray-600 mb-4">{description}</p>' if description else ''}
127 {body_html}
128 </div>
129 {footer_html}
130 </div>
131 '''
132
133 def render_button(self, data: Dict) -> str:
134 """Render Tailwind button"""
135 text = data.get('text', 'Button')
136 variant = data.get('variant', 'primary')
137 size = data.get('size', 'md')
138 onclick = data.get('onclick', '')
139
140 # Variant styles
141 variant_classes = {
142 'primary': 'bg-indigo-600 hover:bg-indigo-700 text-white',
143 'secondary': 'bg-gray-200 hover:bg-gray-300 text-gray-900',
144 'success': 'bg-green-600 hover:bg-green-700 text-white',
145 'danger': 'bg-red-600 hover:bg-red-700 text-white',
146 'warning': 'bg-yellow-500 hover:bg-yellow-600 text-white',
147 'info': 'bg-blue-500 hover:bg-blue-600 text-white'
148 }.get(variant, 'bg-gray-200 hover:bg-gray-300 text-gray-900')
149
150 # Size classes
151 size_classes = {
152 'sm': 'px-3 py-1.5 text-sm',
153 'md': 'px-4 py-2 text-base',
154 'lg': 'px-6 py-3 text-lg'
155 }.get(size, 'px-4 py-2 text-base')
156
157 onclick_attr = f'onclick="{onclick}"' if onclick else ''
158
159 return f'<button class="{variant_classes} {size_classes} font-medium rounded-md shadow-sm" {onclick_attr}>{text}</button>'
160
161 def render_grid(self, data: Dict) -> str:
162 """Render Tailwind grid layout"""
163 columns = data.get('columns', 3)
164 items = data.get('items', [])
165 gap = data.get('gap', 4)
166
167 # Grid column classes
168 col_class = {
169 1: 'grid-cols-1',
170 2: 'grid-cols-1 sm:grid-cols-2',
171 3: 'grid-cols-1 sm:grid-cols-2 lg:grid-cols-3',
172 4: 'grid-cols-1 sm:grid-cols-2 lg:grid-cols-4',
173 6: 'grid-cols-2 sm:grid-cols-3 lg:grid-cols-6'
174 }.get(columns, 'grid-cols-3')
175
176 items_html = ''.join([f'<div>{self.render(item)}</div>' for item in items])
177
178 return f'''
179 <div class="grid {col_class} gap-{gap}">
180 {items_html}
181 </div>
182 '''
183
184 def render_table(self, data: Dict) -> str:
185 """Render Tailwind table"""
186 headers = data.get('headers', [])
187 rows = data.get('rows', [])
188
189 # Create header row
190 header_html = ''.join([
191 f'<th class="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">{header}</th>'
192 for header in headers
193 ])
194
195 # Create data rows
196 rows_html = ''
197 for row in rows:
198 cells_html = ''.join([
199 f'<td class="px-6 py-4 whitespace-nowrap text-sm text-gray-900">{self.render(cell) if isinstance(cell, dict) else cell}</td>'
200 for cell in row
201 ])
202 rows_html += f'<tr class="hover:bg-gray-50">{cells_html}</tr>'
203
204 return f'''
205 <div class="overflow-hidden shadow ring-1 ring-black ring-opacity-5 md:rounded-lg">
206 <table class="min-w-full divide-y divide-gray-300">
207 <thead class="bg-gray-50">
208 <tr>{header_html}</tr>
209 </thead>
210 <tbody class="bg-white divide-y divide-gray-200">
211 {rows_html}
212 </tbody>
213 </table>
214 </div>
215 '''
216
217 def render_form(self, data: Dict) -> str:
218 """Render Tailwind form"""
219 fields = data.get('fields', [])
220 submit = data.get('submit', {})
221 form_id = data.get('id', '')
222
223 fields_html = ''
224 for field in fields:
225 field_html = self.render_form_field(field)
226 fields_html += f'<div class="mb-4">{field_html}</div>'
227
228 submit_html = ''
229 if submit:
230 submit_button = {
231 'type': 'button',
232 'text': submit.get('text', 'Submit'),
233 'variant': submit.get('variant', 'primary')
234 }
235 submit_html = self.render_button(submit_button)
236
237 return f'''
238 <form {f'id="{form_id}"' if form_id else ''} class="space-y-6">
239 {fields_html}
240 <div class="flex justify-end">
241 {submit_html}
242 </div>
243 </form>
244 '''
245
246 def render_form_field(self, field: Dict) -> str:
247 """Render individual form field"""
248 field_type = field.get('type', 'input')
249 label = field.get('label', '')
250 name = field.get('name', '')
251 field_id = field.get('id', name)
252 placeholder = field.get('placeholder', '')
253 required = field.get('required', False)
254
255 label_html = f'<label for="{field_id}" class="block text-sm font-medium text-gray-700 mb-1">{label}</label>' if label else ''
256
257 if field_type == 'input':
258 input_type = field.get('input_type', 'text')
259 return f'''
260 {label_html}
261 <input type="{input_type}" id="{field_id}" name="{name}"
262 class="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-indigo-500 focus:border-indigo-500"
263 placeholder="{placeholder}" {'required' if required else ''}>
264 '''
265 elif field_type == 'textarea':
266 rows = field.get('rows', 4)
267 return f'''
268 {label_html}
269 <textarea id="{field_id}" name="{name}" rows="{rows}"
270 class="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-indigo-500 focus:border-indigo-500"
271 placeholder="{placeholder}" {'required' if required else ''}></textarea>
272 '''
273 elif field_type == 'select':
274 options = field.get('options', [])
275 options_html = ''.join([
276 f'<option value="{opt.get("value", "")}">{opt.get("text", "")}</option>'
277 for opt in options
278 ])
279 return f'''
280 {label_html}
281 <select id="{field_id}" name="{name}"
282 class="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-indigo-500 focus:border-indigo-500">
283 {options_html}
284 </select>
285 '''
286 elif field_type == 'checkbox':
287 return f'''
288 <div class="flex items-center">
289 <input type="checkbox" id="{field_id}" name="{name}"
290 class="h-4 w-4 text-indigo-600 focus:ring-indigo-500 border-gray-300 rounded">
291 <label for="{field_id}" class="ml-2 block text-sm text-gray-900">{label}</label>
292 </div>
293 '''
294
295 return ''
296
297 def render_badge(self, data: Dict) -> str:
298 """Render Tailwind badge"""
299 text = data.get('text', '')
300 variant = data.get('variant', 'default')
301
302 variant_classes = {
303 'default': 'bg-gray-100 text-gray-800',
304 'primary': 'bg-blue-100 text-blue-800',
305 'success': 'bg-green-100 text-green-800',
306 'danger': 'bg-red-100 text-red-800',
307 'warning': 'bg-yellow-100 text-yellow-800',
308 'info': 'bg-indigo-100 text-indigo-800'
309 }.get(variant, 'bg-gray-100 text-gray-800')
310
311 return f'<span class="inline-flex items-center px-2.5 py-0.5 rounded-full text-xs font-medium {variant_classes}">{text}</span>'
312
313 def render_alert(self, data: Dict) -> str:
314 """Render Tailwind alert"""
315 message = data.get('message', '')
316 variant = data.get('variant', 'info')
317
318 variant_classes = {
319 'info': 'bg-blue-50 border-blue-400 text-blue-700',
320 'success': 'bg-green-50 border-green-400 text-green-700',
321 'warning': 'bg-yellow-50 border-yellow-400 text-yellow-700',
322 'danger': 'bg-red-50 border-red-400 text-red-700'
323 }.get(variant, 'bg-blue-50 border-blue-400 text-blue-700')
324
325 return f'''
326 <div class="{variant_classes} border-l-4 p-4" role="alert">
327 <p>{message}</p>
328 </div>
329 '''
330
331 def render_metric(self, data: Dict) -> str:
332 """Render metric display component"""
333 label = data.get('label', '')
334 value = data.get('value', '0')
335 icon = data.get('icon', '')
336 trend = data.get('trend', '')
337
338 icon_html = f'<i class="{icon} text-3xl text-indigo-600"></i>' if icon else ''
339
340 trend_html = ''
341 if trend == 'up':
342 trend_html = '<span class="text-green-600">↑</span>'
343 elif trend == 'down':
344 trend_html = '<span class="text-red-600">↓</span>'
345
346 return f'''
347 <div class="flex items-center justify-between p-4">
348 {icon_html}
349 <div class="text-right">
350 <p class="text-2xl font-bold text-gray-900">{value} {trend_html}</p>
351 <p class="text-sm text-gray-500">{label}</p>
352 </div>
353 </div>
354 '''
355
356 def render_container(self, data: Dict) -> str:
357 """Render Tailwind container"""
358 children = data.get('children', [])
359 fluid = data.get('fluid', False)
360
361 container_class = 'max-w-full' if fluid else 'max-w-7xl'
362
363 children_html = ''.join([self.render(child) for child in children])
364
365 return f'''
366 <div class="{container_class} mx-auto px-4 sm:px-6 lg:px-8">
367 {children_html}
368 </div>
369 '''
370
371 def render(self, data: Any) -> str:
372 """Main render method"""
373 if isinstance(data, str):
374 return data
375
376 if isinstance(data, list):
377 return ''.join([self.render(item) for item in data])
378
379 if isinstance(data, dict):
380 component_type = data.get('type', '')
381
382 # Map component types to render methods
383 renderers = {
384 'page': self.render_page,
385 'navbar': self.render_navbar,
386 'hero': self.render_hero,
387 'card': self.render_card,
388 'button': self.render_button,
389 'grid': self.render_grid,
390 'table': self.render_table,
391 'form': self.render_form,
392 'badge': self.render_badge,
393 'alert': self.render_alert,
394 'metric': self.render_metric,
395 'container': self.render_container
396 }
397
398 renderer = renderers.get(component_type)
399 if renderer:
400 return renderer(data)
401
402 return str(data)
403
404
405# Example usage
406if __name__ == "__main__":
407 from presentation_layer import PresentationLayer
408
409 # Register Tailwind renderer
410 PresentationLayer.add_renderer('tailwind', TailwindRenderer())
411
412 # Example data structure
413 ui_data = {
414 'type': 'page',
415 'title': 'DBBasic - Tailwind Version',
416 'components': [
417 {
418 'type': 'navbar',
419 'brand': 'DBBasic',
420 'variant': 'dark',
421 'links': [
422 {'text': 'Dashboard', 'url': '/'},
423 {'text': 'Services', 'url': '/services'},
424 {'text': 'Templates', 'url': '/templates'}
425 ]
426 },
427 {
428 'type': 'hero',
429 'title': 'Welcome to DBBasic',
430 'subtitle': 'The Post-Code Era Platform',
431 'variant': 'gradient-blue'
432 },
433 {
434 'type': 'container',
435 'children': [
436 {
437 'type': 'grid',
438 'columns': 3,
439 'items': [
440 {
441 'type': 'card',
442 'title': 'Fast Performance',
443 'body': {
444 'type': 'metric',
445 'label': 'Queries/sec',
446 'value': '402M',
447 'icon': 'fas fa-rocket',
448 'trend': 'up'
449 }
450 },
451 {
452 'type': 'card',
453 'title': 'AI Powered',
454 'body': 'Generate business logic from natural language'
455 },
456 {
457 'type': 'card',
458 'title': 'Config Driven',
459 'body': 'Define apps with YAML, not code'
460 }
461 ]
462 }
463 ]
464 }
465 ]
466 }
467
468 # Render with Tailwind
469 html = PresentationLayer.render(ui_data, 'tailwind')
470
471 # Save to file
472 with open('static/tailwind_demo.html', 'w') as f:
473 f.write(html)
474
475 print("✅ Generated Tailwind demo at static/tailwind_demo.html")
476 print("\nYou can now switch between frameworks:")
477 print(" Bootstrap: PresentationLayer.render(data, 'bootstrap')")
478 print(" Tailwind: PresentationLayer.render(data, 'tailwind')")