nicegui-rdm 0.1.0__tar.gz

nicegui_rdm-0.1.0/.gitignore

@@ -0,0 +1,54 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+.nicegui/
+
+# Virtual environments
+venv/
+env/
+ENV/
+
+# AI assistant working files
+cline_docs/
+.clinerules
+CLAUDE.md
+.claude/
+
+# IDE files
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS specific files
+.DS_Store
+Thumbs.db
+
+# Pytest
+.pytest_cache/
+.coverage
+htmlcov/
+
+# database files
+*.db
+*.sqlite3
+*.sqlite3-shm
+*.sqlite3-wal

nicegui_rdm-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Peter Kleynjan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

nicegui_rdm-0.1.0/PKG-INFO

@@ -0,0 +1,170 @@
+Metadata-Version: 2.3
+Name: nicegui-rdm
+Version: 0.1.0
+Summary: Reactive Data Management for NiceGUI with Tortoise ORM
+Project-URL: Homepage, https://github.com/kleynjan/nicegui-rdm
+Project-URL: Repository, https://github.com/kleynjan/nicegui-rdm
+Author: Peter Kleynjan
+License: MIT
+Keywords: crud,data-management,nicegui,reactive,tortoise-orm
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.12
+Requires-Dist: nicegui<4.0,>=3.0
+Requires-Dist: pytz
+Requires-Dist: tortoise-orm<2.0.0,>=1.0.0
+Provides-Extra: dev
+Requires-Dist: httpx; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest-cov>=5.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# nicegui-rdm: Reactive Data Management
+
+## Why: in a nutshell
+
+ng_rdm offers a clean and modern set of (non-Quasar) tables with all the plumbing you need to build database-backed NiceGUI applications. Moreover, these tables can automatically refresh when back-end data is added or modified. Hence: **reactive** data management. 
+ 
+## Background (feel free to skip)
+
+ng_rdm is based on two ideas:
+
+1. For my own apps I needed to add **reactivity to database applications**: changes in data should be reflected in UI components, *without* the user having to refresh a page. Imagine a table showing items, counts, stock being updated in near real-time as data is changing. This is the core of the library, implemented in `models` and `store`. Note: this is similar to but *complementary* to the reactivity we can easily achieve &lsquo;client-side&rsquo; with  NiceGUI bindings etc. 
+
+2. Secondly, I've always been fighting Quasar's **&ldquo;composite&rdquo; UI components** such as tables, dialogs, cards, etc.: layer upon layer of div's and the most obnoxious CSS imaginable. Thanks to NiceGUI's websocket architecture we can move the logic for and behavior of those components from JavaScript/VueJS over to the Python side. In `components/widgets` you'll find tables that create clean html with semantic CSS selectors and that tie in to `store` observability &ndash; entirely in Python. 
+
+See below for a more detailed overview of the architecture.
+
+
+## Installation
+
+```bash
+pip install nicegui-rdm
+```
+
+## Architecture
+
+```
+┌──────────────────────────────────────────────────────────┐
+│  UI Components                                           │
+│  ActionButtonTable · ListTable · SelectionTable          │
+│  EditDialog · EditCard · DetailCard · ViewStack          │
+└──────────────┬─────────────────────────────────┬─────────┘
+               │  1. user action                 ▲
+               ▼                                 │  6. notify_observers
+┌──────────────┴─────────────────────────────────┴─────────┐
+│  Store Layer                                             │
+│  Store (base) · DictStore · TortoiseStore                │
+│  MultitenantTortoiseStore · StoreRegistry                │
+│  CRUD · validation · observer pattern                    │
+└──────────────┬─────────────────────────────────┬─────────┘
+               │  2. validate & write            ▲
+               ▼                                 │  5. return result
+┌──────────────┴─────────────────────────────────┴─────────┐
+│  Data Layer                                              │
+│  Tortoise ORM · QModel                                   │
+│  SQLite · PostgreSQL · MySQL                             │
+└──────────────────────────────────────────────────────────┘
+```
+
+User actions flow **down** through the Store layer (which validates and normalizes) to the database. On success, the Store broadcasts a `StoreEvent` **up** to all subscribed UI components, which automatically rebuild via `@ui.refreshable_method`. This is the reactive loop that keeps tables and detail views in sync with the database without manual refresh.
+
+## Quick Start
+
+```python
+from nicegui import app, ui
+from tortoise import fields
+
+from ng_rdm import TortoiseStore, init_db, close_db, FieldSpec, Validator
+from ng_rdm.models import QModel
+from ng_rdm.components import (
+    rdm_init, Column, TableConfig, FormConfig,
+    ActionButtonTable, EditDialog,
+)
+
+# 1. Define a model with validation
+class Task(QModel):
+    id = fields.IntField(pk=True)
+    name = fields.CharField(max_length=100)
+
+    field_specs = {
+        "name": FieldSpec(validators=[
+            Validator("Name is required", lambda v, _: bool(v and v.strip()))
+        ])
+    }
+
+# 2. Initialize database and create a store (module level)
+init_db(app, "sqlite://tasks.db", modules={"models": [__name__]}, generate_schemas=True)
+app.on_shutdown(close_db)
+
+task_store = TortoiseStore(Task)
+
+# 3. Build a page
+@ui.page("/")
+async def index():
+    rdm_init()  # load CSS + Bootstrap Icons
+
+    columns = [Column("name", "Task name")]
+    table_config = TableConfig(columns=columns)
+    form_config = FormConfig(columns=columns, title_add="New Task", title_edit="Edit Task")
+
+    # EditDialog for add/edit; ActionButtonTable for display
+    dlg = EditDialog(data_source=task_store, config=form_config,
+                     on_saved=lambda _: table.build.refresh())
+    table = ActionButtonTable(
+        data_source=task_store, config=table_config,
+        on_add=dlg.open_for_new, on_edit=dlg.open_for_edit,
+    )
+    await table.build()
+
+ui.run()
+```
+
+## What's Included
+
+**Tables** — `ActionButtonTable` (CRUD with per-row action buttons), `ListTable` (read-only clickable rows), `SelectionTable` (checkbox multi-select)
+
+**Forms** — `EditDialog` (modal create/edit), `EditCard` (inline form)
+
+**Navigation** — `ViewStack` (list/detail/edit flow), `Tabs` (tabbed content)
+
+**Display** — `DetailCard` (read-only detail view), `Dialog` (modal overlay), `StepWizard` (multi-step form)
+
+**Layout** — `Button`, `IconButton`, `Icon`, `Row`, `Col`, `Separator`
+
+**Store layer** — `DictStore` (in-memory), `TortoiseStore` (ORM-backed), `MultitenantTortoiseStore` (tenant-scoped)
+
+See [`components/API.md`](components/API.md) for the full component API reference.
+
+## Examples
+
+Run any example with `python -m ng_rdm.examples.<name>` and open http://localhost:8080.
+
+| Example | Description |
+|---------|-------------|
+| `catalog` | Component catalog — showcases all widgets |
+| `master_detail` | ViewStack master-detail navigation |
+| `custom_datasource` | Custom `RdmDataSource` implementation |
+| `vanilla_store` | Basic store usage without UI components |
+| `topic_filtering` | Topic-based observer filtering |
+
+## Some notes
+
+
+
+## Requirements
+
+- Python 3.12+
+- NiceGUI >= 1.4.0
+- Tortoise ORM >= 0.20.0
+- pytz
+
+## License
+
+MIT

nicegui_rdm-0.1.0/README.md

@@ -0,0 +1,143 @@
+# nicegui-rdm: Reactive Data Management
+
+## Why: in a nutshell
+
+ng_rdm offers a clean and modern set of (non-Quasar) tables with all the plumbing you need to build database-backed NiceGUI applications. Moreover, these tables can automatically refresh when back-end data is added or modified. Hence: **reactive** data management. 
+ 
+## Background (feel free to skip)
+
+ng_rdm is based on two ideas:
+
+1. For my own apps I needed to add **reactivity to database applications**: changes in data should be reflected in UI components, *without* the user having to refresh a page. Imagine a table showing items, counts, stock being updated in near real-time as data is changing. This is the core of the library, implemented in `models` and `store`. Note: this is similar to but *complementary* to the reactivity we can easily achieve ‘client-side’ with  NiceGUI bindings etc. 
+
+2. Secondly, I've always been fighting Quasar's **“composite” UI components** such as tables, dialogs, cards, etc.: layer upon layer of div's and the most obnoxious CSS imaginable. Thanks to NiceGUI's websocket architecture we can move the logic for and behavior of those components from JavaScript/VueJS over to the Python side. In `components/widgets` you'll find tables that create clean html with semantic CSS selectors and that tie in to `store` observability – entirely in Python. 
+
+See below for a more detailed overview of the architecture.
+
+
+## Installation
+
+```bash
+pip install nicegui-rdm
+```
+
+## Architecture
+
+```
+┌──────────────────────────────────────────────────────────┐
+│  UI Components                                           │
+│  ActionButtonTable · ListTable · SelectionTable          │
+│  EditDialog · EditCard · DetailCard · ViewStack          │
+└──────────────┬─────────────────────────────────┬─────────┘
+               │  1. user action                 ▲
+               ▼                                 │  6. notify_observers
+┌──────────────┴─────────────────────────────────┴─────────┐
+│  Store Layer                                             │
+│  Store (base) · DictStore · TortoiseStore                │
+│  MultitenantTortoiseStore · StoreRegistry                │
+│  CRUD · validation · observer pattern                    │
+└──────────────┬─────────────────────────────────┬─────────┘
+               │  2. validate & write            ▲
+               ▼                                 │  5. return result
+┌──────────────┴─────────────────────────────────┴─────────┐
+│  Data Layer                                              │
+│  Tortoise ORM · QModel                                   │
+│  SQLite · PostgreSQL · MySQL                             │
+└──────────────────────────────────────────────────────────┘
+```
+
+User actions flow **down** through the Store layer (which validates and normalizes) to the database. On success, the Store broadcasts a `StoreEvent` **up** to all subscribed UI components, which automatically rebuild via `@ui.refreshable_method`. This is the reactive loop that keeps tables and detail views in sync with the database without manual refresh.
+
+## Quick Start
+
+```python
+from nicegui import app, ui
+from tortoise import fields
+
+from ng_rdm import TortoiseStore, init_db, close_db, FieldSpec, Validator
+from ng_rdm.models import QModel
+from ng_rdm.components import (
+    rdm_init, Column, TableConfig, FormConfig,
+    ActionButtonTable, EditDialog,
+)
+
+# 1. Define a model with validation
+class Task(QModel):
+    id = fields.IntField(pk=True)
+    name = fields.CharField(max_length=100)
+
+    field_specs = {
+        "name": FieldSpec(validators=[
+            Validator("Name is required", lambda v, _: bool(v and v.strip()))
+        ])
+    }
+
+# 2. Initialize database and create a store (module level)
+init_db(app, "sqlite://tasks.db", modules={"models": [__name__]}, generate_schemas=True)
+app.on_shutdown(close_db)
+
+task_store = TortoiseStore(Task)
+
+# 3. Build a page
+@ui.page("/")
+async def index():
+    rdm_init()  # load CSS + Bootstrap Icons
+
+    columns = [Column("name", "Task name")]
+    table_config = TableConfig(columns=columns)
+    form_config = FormConfig(columns=columns, title_add="New Task", title_edit="Edit Task")
+
+    # EditDialog for add/edit; ActionButtonTable for display
+    dlg = EditDialog(data_source=task_store, config=form_config,
+                     on_saved=lambda _: table.build.refresh())
+    table = ActionButtonTable(
+        data_source=task_store, config=table_config,
+        on_add=dlg.open_for_new, on_edit=dlg.open_for_edit,
+    )
+    await table.build()
+
+ui.run()
+```
+
+## What's Included
+
+**Tables** — `ActionButtonTable` (CRUD with per-row action buttons), `ListTable` (read-only clickable rows), `SelectionTable` (checkbox multi-select)
+
+**Forms** — `EditDialog` (modal create/edit), `EditCard` (inline form)
+
+**Navigation** — `ViewStack` (list/detail/edit flow), `Tabs` (tabbed content)
+
+**Display** — `DetailCard` (read-only detail view), `Dialog` (modal overlay), `StepWizard` (multi-step form)
+
+**Layout** — `Button`, `IconButton`, `Icon`, `Row`, `Col`, `Separator`
+
+**Store layer** — `DictStore` (in-memory), `TortoiseStore` (ORM-backed), `MultitenantTortoiseStore` (tenant-scoped)
+
+See [`components/API.md`](components/API.md) for the full component API reference.
+
+## Examples
+
+Run any example with `python -m ng_rdm.examples.<name>` and open http://localhost:8080.
+
+| Example | Description |
+|---------|-------------|
+| `catalog` | Component catalog — showcases all widgets |
+| `master_detail` | ViewStack master-detail navigation |
+| `custom_datasource` | Custom `RdmDataSource` implementation |
+| `vanilla_store` | Basic store usage without UI components |
+| `topic_filtering` | Topic-based observer filtering |
+
+## Some notes
+
+
+
+## Requirements
+
+- Python 3.12+
+- NiceGUI >= 1.4.0
+- Tortoise ORM >= 0.20.0
+- pytz
+
+## License
+
+MIT

nicegui_rdm-0.1.0/check_styles.py

@@ -0,0 +1,196 @@
+"""
+CSS audit script for ng_rdm.css.
+
+Extracts all .rdm-* class definitions from the CSS file and cross-references
+them against usage in Python source files, reporting:
+  - Unused classes (defined in CSS, not referenced in Python)
+  - Missing classes (referenced in Python, not defined in CSS)
+  - Duplicate selectors (same class defined in multiple rule blocks)
+
+Usage:
+    python check_styles.py
+    python check_styles.py --consumer /path/to/consumer/app
+"""
+
+import argparse
+import re
+import sys
+from collections import defaultdict
+from pathlib import Path
+
+CSS_FILE = Path('src/ng_rdm/components/ng_rdm.css')
+SRC_DIR = Path('src/ng_rdm')
+
+# Known color variants for dynamic f-string patterns in button.py
+COLOR_VARIANTS = ['default', 'primary', 'secondary', 'success', 'warning', 'danger', 'text']
+
+# F-string class templates: prefix -> list of suffixes
+DYNAMIC_TEMPLATES: dict[str, list[str]] = {
+    'rdm-btn': COLOR_VARIANTS,
+    'rdm-btn-icon': COLOR_VARIANTS,
+    'rdm-icon': COLOR_VARIANTS,
+}
+
+
+# ---------------------------------------------------------------------------
+# CSS parsing
+# ---------------------------------------------------------------------------
+
+def extract_css_classes(css_path: Path) -> dict[str, list[int]]:
+    """Return {class_name: [line_numbers]} for all active .rdm-* class selectors."""
+    result: dict[str, list[int]] = defaultdict(list)
+    in_block_comment = False
+
+    for i, line in enumerate(css_path.read_text().splitlines(), 1):
+        stripped = line.strip()
+
+        # Track block comments /* ... */
+        if '/*' in stripped:
+            in_block_comment = True
+        if in_block_comment:
+            if '*/' in stripped:
+                in_block_comment = False
+            continue
+
+        for match in re.finditer(r'\.(rdm-[a-zA-Z0-9_-]+)', line):
+            result[match.group(1)].append(i)
+
+    return dict(result)
+
+
+def find_duplicate_selectors(css_classes: dict[str, list[int]]) -> dict[str, list[int]]:
+    """Return classes whose selector appears in more than one distinct rule block."""
+    return {cls: lines for cls, lines in css_classes.items() if len(set(lines)) > 1}
+
+
+# ---------------------------------------------------------------------------
+# Python scanning
+# ---------------------------------------------------------------------------
+
+def expand_dynamic_classes(template: str) -> list[str]:
+    """Expand f-string template like 'rdm-btn-{color}' to concrete class names."""
+    for prefix, variants in DYNAMIC_TEMPLATES.items():
+        pattern = re.compile(re.escape(prefix) + r'-\{[^}]+\}')
+        if pattern.search(template):
+            return [f'{prefix}-{v}' for v in variants]
+    return []
+
+
+def scan_python_file(path: Path) -> set[str]:
+    """Return all rdm-* class names referenced in a Python file."""
+    content = path.read_text()
+    found: set[str] = set()
+
+    # 1. F-string templates first: f'rdm-btn-{color}' etc.
+    #    Process before literal scan to avoid double-counting truncated prefixes.
+    fstring_spans: list[tuple[int, int]] = []
+    for m in re.finditer(r'f["\']([^"\']*rdm-[^"\']*\{[^}]+\}[^"\']*)["\']', content):
+        fstring_spans.append((m.start(), m.end()))
+        expanded = expand_dynamic_classes(m.group(1))
+        found.update(expanded)  # may be empty if template not recognised — that's fine
+
+    # 2. Literal strings outside f-string spans
+    for m in re.finditer(r'["\']([^"\']*rdm-[^"\']*)["\']', content):
+        # Skip if this match overlaps an already-processed f-string
+        if any(s <= m.start() <= e for s, e in fstring_spans):
+            continue
+        for cls in re.findall(r'rdm-[a-zA-Z0-9_-]+', m.group(1)):
+            if not cls.endswith('-'):  # skip truncated f-string fragments
+                found.add(cls)
+
+    # 3. _css_class attribute assignments
+    for m in re.finditer(r'_css_class\s*=\s*["\']([^"\']+)["\']', content):
+        for cls in m.group(1).split():
+            if cls.startswith('rdm-'):
+                found.add(cls)
+
+    return found
+
+
+def scan_directory(directory: Path) -> dict[str, set[str]]:
+    """Return {class_name: {file_paths}} for all rdm-* references in .py files."""
+    usage: dict[str, set[str]] = defaultdict(set)
+    root = Path.cwd().resolve()
+    for py_file in directory.resolve().rglob('*.py'):
+        label = str(py_file.relative_to(root)) if py_file.is_relative_to(root) else str(py_file)
+        for cls in scan_python_file(py_file):
+            usage[cls].add(label)
+    return dict(usage)
+
+
+# ---------------------------------------------------------------------------
+# Reporting
+# ---------------------------------------------------------------------------
+
+def print_section(title: str, items: list[str]) -> None:
+    print(f'\n{"=" * 60}')
+    print(f'  {title} ({len(items)})')
+    print('=' * 60)
+    for item in sorted(items):
+        print(f'  {item}')
+    if not items:
+        print('  (none)')
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description='Audit ng_rdm.css for unused/missing classes.')
+    parser.add_argument('--consumer', metavar='PATH', help='Also scan a consumer app directory')
+    args = parser.parse_args()
+
+    if not CSS_FILE.exists():
+        print(f'Error: {CSS_FILE} not found. Run from the project root.', file=sys.stderr)
+        sys.exit(1)
+
+    # --- Extract CSS definitions ---
+    css_classes = extract_css_classes(CSS_FILE)
+    print(f'CSS: {len(css_classes)} distinct rdm-* class names in {CSS_FILE}')
+
+    # --- Scan Python usage ---
+    usage = scan_directory(SRC_DIR)
+    if args.consumer:
+        consumer_path = Path(args.consumer)
+        if not consumer_path.exists():
+            print(f'Warning: consumer path {consumer_path} not found', file=sys.stderr)
+        else:
+            consumer_usage = scan_directory(consumer_path)
+            for cls, files in consumer_usage.items():
+                if cls not in usage:
+                    usage[cls] = set()
+                usage[cls].update(files)
+            print(f'Consumer: also scanned {consumer_path}')
+
+    print(f'Python: {len(usage)} distinct rdm-* class names referenced')
+
+    # --- Cross-reference ---
+    defined = set(css_classes.keys())
+    referenced = set(usage.keys())
+
+    unused = defined - referenced
+    missing = referenced - defined
+
+    duplicates = find_duplicate_selectors(css_classes)
+
+    # --- Output ---
+    print_section('UNUSED (defined in CSS, not found in Python)', list(unused))
+
+    if missing:
+        print_section('MISSING from CSS (referenced in Python, not defined)', list(missing))
+
+    if duplicates:
+        print('\n' + '=' * 60)
+        print(f'  DUPLICATE SELECTORS ({len(duplicates)})')
+        print('=' * 60)
+        for cls, lines in sorted(duplicates.items()):
+            print(f'  .{cls}  — lines: {lines}')
+
+    # Usage detail for referenced classes
+    print('\n' + '=' * 60)
+    print('  USAGE DETAIL (referenced classes with file counts)')
+    print('=' * 60)
+    for cls in sorted(referenced & defined):
+        files = usage[cls]
+        print(f'  {cls:<45} {len(files)} file(s)')
+
+
+if __name__ == '__main__':
+    main()

nicegui_rdm-0.1.0/keyboard_output.log

@@ -0,0 +1,6 @@
+NiceGUI ready to go on http://localhost:8080, and http://192.168.178.229:8080
+2026-04-06 18:02:52.725 osascript[53846:16634124] ApplePersistence=NO
+WARNING:  WatchFiles detected changes in 'test_keyboard2.py'. Reloading...
+NiceGUI ready to go on http://localhost:8080, and http://192.168.178.229:8080
+WARNING:  WatchFiles detected changes in 'src/ng_rdm/components/widgets/dialog.py'. Reloading...
+NiceGUI ready to go on http://localhost:8080, and http://192.168.178.229:8080

nicegui_rdm-0.1.0/pyproject.toml

@@ -0,0 +1,60 @@
+[build-system]
+requires = ["hatchling<1.27"]
+build-backend = "hatchling.build"
+
+[project]
+name = "nicegui-rdm"
+version = "0.1.0"
+description = "Reactive Data Management for NiceGUI with Tortoise ORM"
+readme = "README.md"
+requires-python = ">=3.12"
+license = "MIT"
+authors = [
+    { name = "Peter Kleynjan" },
+]
+keywords = ["nicegui", "tortoise-orm", "reactive", "data-management", "crud"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = [
+    "nicegui>=3.0,<4.0",
+    "tortoise-orm>=1.0.0,<2.0.0",
+    "pytz",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0",
+    "pytest-asyncio>=0.23",
+    "pytest-cov>=5.0",
+    "httpx",
+]
+
+[project.urls]
+Homepage = "https://github.com/kleynjan/nicegui-rdm"
+Repository = "https://github.com/kleynjan/nicegui-rdm"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/ng_rdm"]
+exclude = ["*.sqlite3"]
+
+[tool.pytest.ini_options]
+addopts = "-W ignore::DeprecationWarning -W ignore::PendingDeprecationWarning -W ignore::pytest.PytestDeprecationWarning -v"
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "session"
+asyncio_default_test_loop_scope = "session"
+main_file = ""
+testpaths = ["tests"]
+python_files = "test_*.py"
+python_classes = "Test*"
+python_functions = "test_*"
+markers = [
+    "slow: marks tests as slow (deselect with '-m \"not slow\"')",
+    "components: component/widget UI tests using NiceGUI User fixture",
+]

nicegui_rdm-0.1.0/requirements-test.txt

@@ -0,0 +1,4 @@
+pytest>=8.0
+pytest-asyncio>=0.23
+pytest-cov>=5.0
+httpx

nicegui_rdm-0.1.0/requirements.txt

@@ -0,0 +1,3 @@
+nicegui>=3.0,<4.0
+tortoise-orm>=1.0.0,<2.0.0
+pytz