niceforms 0.1.0__py3-none-any.whl

niceforms/__init__.py

@@ -0,0 +1,88 @@
+import logging
+from pprint import pprint
+from typing import Type, Optional
+
+from nicegui import ui
+from pydantic import BaseModel
+from pydantic.fields import FieldInfo
+
+from actions import OnSubmit
+from constants import *
+from ui import UIComponent
+from ui.body import Body
+from ui.footer import Footer
+from ui.header import Header
+from utils import get_nested_models
+from widget_factory import WidgetFactory
+
+logger = logging.getLogger(__name__)
+factory = WidgetFactory()
+
+
+class BaseModelForm(UIComponent):
+    def __init__(
+        self,
+        model: Type[BaseModel],
+        on_submit: Optional[OnSubmit] = None,
+        title: Optional[str] = None,
+        header_bg_color: Optional[str] = None,
+        view_annotation_type: bool = True,
+    ) -> None:
+        """Initialize universal form.
+
+        Args:
+            model: Pydantic model class
+            on_submit: Callback function for form submission
+            title: Form title (if None, uses model name)
+        """
+        self.model = model
+        self.on_submit = on_submit
+        self.title = title or model.__name__
+        self.header_bg_color = header_bg_color
+        self.view_annotation_type = view_annotation_type
+
+        # style
+        self._card = None # тело всей формы
+        self._is_nested = False
+
+    def render(self) -> None:
+        """Render the form UI."""
+        nested_models = get_nested_models(self.model)
+        fields: dict[str, FieldInfo] = self.model.model_fields  # type: ignore
+
+        for n_model in nested_models:
+            try:
+                del fields[n_model.field_name]
+            except KeyError:
+                logger.debug(f'Field "{n_model.field_name}" is not defined')
+
+        widgets = factory.build(
+            model_fields=fields, view_annotation_type=self.view_annotation_type
+        )
+
+        with ui.card().classes(
+            f"w-full {DEFAULT_FORM_WIDTH} mx-auto shadow-lg rounded-xl overflow-hidden"
+        ) as self._card:
+            Header(
+                title=self.title,
+                description=self.model.__doc__,
+                bg_color=self.header_bg_color,
+                parent_card=self._card,
+                is_nested=self._is_nested,
+            ).render()
+
+            elements = Body(widgets).render()
+
+            for n_model in nested_models:
+                if not self._is_nested:
+                    nested_form = BaseModelForm(n_model.model, header_bg_color='#2eeead')
+                    nested_form._is_nested = True
+                    nested_form.render()
+                    nested_form._card.style('height: 100px')
+
+            Footer(
+                elements=elements,
+                is_nested=self._is_nested,
+                model=self.model,
+                on_submit=self.on_submit,
+            ).render()

niceforms/actions.py

@@ -0,0 +1,8 @@
+from typing import Protocol
+
+from pydantic import BaseModel
+
+
+class OnSubmit(Protocol):
+    async def __call__(self, model: BaseModel) -> None: ...
+

niceforms/constants.py

@@ -0,0 +1,11 @@
+"""Константы приложения.""" 
+
+DEFAULT_FORM_WIDTH = "max-w-2xl"
+PRIMARY_COLOR_GRADIENT = "linear-gradient(to right, #3b82f6, #9333ea)"
+ERROR_BACKGROUND_COLOR = "bg-red-50"
+ERROR_BORDER_COLOR = "border-red-200"
+SUCCESS_BACKGROUND_COLOR = "bg-green-50"
+SUCCESS_BORDER_COLOR = "border-green-200"
+NULL_OPTION_VALUE = "__null__"
+NULL_OPTION_LABEL = "<Не указано>"
+DEFAULT_PADDING = "p-4"

niceforms/ui/__init__.py

@@ -0,0 +1,13 @@
+"""Компоненты пользовательского интерфейса."""
+from abc import ABC, abstractmethod
+# from .header import Header
+# from .body import Body
+
+class UIComponent(ABC):
+
+    @abstractmethod
+    def render(self) -> None:
+        raise NotImplementedError()
+
+
+

niceforms/ui/body.py

@@ -0,0 +1,22 @@
+from nicegui import ui
+from nicegui.elements.mixins.value_element import ValueElement
+
+from niceforms import UIComponent
+from widget import BaseWidget, RenderedWidget
+
+
+class Body:
+    def __init__(self, widgets: list[BaseWidget]) -> None:
+        self.widgets = widgets
+
+    def render(self) -> list[RenderedWidget]:
+        elements = []
+
+        with ui.column().classes(f"w-full p-4 space-y-3"):
+            for w in self.widgets:
+                with ui.element().classes(f"w-full"):
+                    w.render_label()
+                    el = w.render()
+                    elements.append(el)
+
+        return elements

niceforms/ui/footer.py

@@ -0,0 +1,76 @@
+import logging
+from typing import Optional, Any
+
+from nicegui import ui
+from nicegui.elements.button import Button
+from pydantic import BaseModel
+
+from actions import OnSubmit
+from niceforms import UIComponent, PRIMARY_COLOR_GRADIENT
+from ui.json_viewer import JsonDialog
+from widget import RenderedWidget
+
+logger = logging.getLogger(__name__)
+
+
+class Footer(UIComponent):
+    def __init__(self, elements: list[RenderedWidget], is_nested: bool, model: type[BaseModel],
+                 on_submit: Optional[OnSubmit]) -> None:
+        self.elements = elements
+        self.is_nested = is_nested
+        self.model = model
+        self.on_submit = on_submit
+
+        self._write_to_form_button: Optional[Button] = None
+        self._submit_button: Optional[Button] = None
+
+    def init_base_model(self) -> BaseModel:
+        data: dict[str, Any] = {}
+
+        for element in self.elements:
+            data[element.widget.field_name] = element.collect()
+
+        return self.model(**data)
+
+    def clear_form(self) -> None:
+        logger.debug('Cleared form')
+        for element in self.elements:
+            element.clear()
+
+    def render_json_viewer_dialog(self) -> None:
+        JsonDialog(model=self.init_base_model()).render()
+
+    def _write_nested_form_to_main_form(self) -> None:
+        pass
+
+    async def submit(self) -> None:
+
+        if self.on_submit is None:
+            logger.warning(f"on_submit function do not provided")
+            return None
+
+        await self.on_submit(self.init_base_model())
+        return None
+
+    def render(self) -> None:
+        with ui.row().classes("w-full justify-end gap-3"):
+            ui.button("Очистить", on_click=self.clear_form).props(
+                "outlined flat"
+            ).classes("px-6 py-2")
+
+            ui.button("Показать json", on_click=self.render_json_viewer_dialog).props(
+                "outlined flat"
+            ).classes("px-6 py-2")
+
+            if self.is_nested:
+                self._write_to_form_button = (
+                    ui.button("Сохранить в форму", on_click=self._write_nested_form_to_main_form)
+                    .props("unelevated")
+                    .classes(f"{PRIMARY_COLOR_GRADIENT} text-white px-8 py-2")
+                )
+            else:
+                self._submit_button = (
+                    ui.button("Отправить", on_click=self.submit, icon="send")
+                    .props("unelevated")
+                    .classes(f"{PRIMARY_COLOR_GRADIENT} text-white px-8 py-2")
+                )

niceforms/ui/header.py

@@ -0,0 +1,54 @@
+from typing import Optional
+
+from nicegui import ui
+from nicegui.element import Element
+from nicegui.elements.button import Button
+
+from niceforms import UIComponent
+from niceforms.constants import DEFAULT_PADDING, PRIMARY_COLOR_GRADIENT
+
+
+class Header(UIComponent):
+    def __init__(
+        self,
+        title: str,
+        description: Optional[str],
+        parent_card: Element,
+        is_nested: bool,
+        bg_color: Optional[str] = None,
+    ) -> None:
+        self.title = title
+        self.description = description
+        self.parent_card = parent_card
+        self.is_nested = is_nested
+        self.bg_color = bg_color if bg_color else PRIMARY_COLOR_GRADIENT
+
+        self._is_expanded = False
+        self._button: Optional[Button] = None
+
+    def toggle_expand_parent(self) -> None:
+        if self._is_expanded:
+            self.parent_card.style('height: 100px')
+            self._is_expanded = False
+            self._button.text = 'Развернуть'
+        else:
+            self.parent_card.style('height: 100%')
+            self._is_expanded = True
+            self._button.text = 'Свернуть'
+
+    def render(self) -> None:
+        with ui.element().classes(f"w-full {DEFAULT_PADDING} rounded-lg").style(
+            f'background: {self.bg_color}'
+        ):
+            # Контейнер для заголовка и кнопки
+            with ui.element().classes("flex justify-between items-start"):
+                ui.label(self.title).classes("text-2xl font-bold text-white")
+
+                if self.is_nested:
+                    self._button = ui.button('Развернуть', on_click=self.toggle_expand_parent).classes(
+                        "px-4 py-2 bg-white/20 hover:bg-white/30 rounded-lg text-white "
+                        "transition-all duration-200 text-sm font-medium"
+                    ).props("outlined flat")
+
+            if self.description:
+                ui.label(self.description).classes("text-blue-100 mt-2")

niceforms/ui/json_viewer.py

@@ -0,0 +1,25 @@
+from nicegui import ui
+from pydantic import BaseModel
+
+from niceforms import UIComponent
+
+
+class JsonDialog(UIComponent):
+    def __init__(self, model: BaseModel):
+        self.model = model
+
+    def render(self) -> None:
+
+        json_data = {'content': {'json': self.model.model_dump()}}
+
+        with ui.dialog() as dialog, ui.card():
+            ui.label('Результирующий JSON объект').classes('text-h5 font-bold')
+            ui.label('(только чтение)')
+
+            # ui.json автоматически красиво форматирует JSON
+            ui.json_editor(json_data).classes('w-full')
+
+            with ui.row().classes('justify-end w-full mt-4'):
+                ui.button('Close', on_click=dialog.close).props('flat')
+
+        dialog.open()

niceforms/utils.py

@@ -0,0 +1,95 @@
+import logging
+from enum import Enum
+from types import NoneType, UnionType
+from typing import Type, Any, get_type_hints
+from typing import Union, get_origin, get_args
+
+from pydantic import BaseModel
+
+logger = logging.getLogger(__name__)
+
+
+class NormalizedType(BaseModel):
+    is_nullable: bool
+    origin_type: Union[type, Any]
+
+
+def normalize_type(field_type: type | UnionType) -> NormalizedType:
+    origin = get_origin(field_type)
+    args = get_args(field_type)
+
+    if origin is UnionType:
+
+        if NoneType in args:
+            return NormalizedType(is_nullable=True, origin_type=field_type)
+        else:
+            return NormalizedType(is_nullable=False, origin_type=field_type)
+
+    if origin is None:
+        return NormalizedType(is_nullable=False, origin_type=field_type)
+
+    if origin is Union:
+
+        if NoneType in args:
+            non_nullable = [x for x in args if x is not NoneType]
+            if len(non_nullable) == 1:
+                return NormalizedType(is_nullable=True, origin_type=non_nullable[0])
+            return NormalizedType(is_nullable=True, origin_type=field_type)
+        else:
+            return NormalizedType(is_nullable=False, origin_type=field_type)
+
+    return NormalizedType(is_nullable=False, origin_type=field_type)
+
+
+def is_enum_type(field_type: type) -> bool:
+    return isinstance(field_type, type) and issubclass(field_type, Enum)
+
+
+class NestedModel(BaseModel):
+    model: type[BaseModel]
+    field_name: str
+
+def extract_model_from_type(attr_type) -> list[tuple[type[BaseModel], str]]:
+    """
+    Рекурсивно извлекает модели BaseModel из типа, обрабатывая Union/Optional.
+    Возвращает список кортежей (модель, field_name) - field_name будет использован позже.
+    """
+    result = []
+
+    # Получаем оригинальный тип и аргументы
+    origin = get_origin(attr_type)
+
+    if origin is Union or origin is UnionType:
+        # Это Union/Optional тип, обрабатываем каждый аргумент
+        for arg in get_args(attr_type):
+            result.extend(extract_model_from_type(arg))
+    elif (
+        isinstance(attr_type, type)
+        and issubclass(attr_type, BaseModel)
+        and attr_type != BaseModel
+    ):
+        # Это непосредственно класс BaseModel
+        result.append(attr_type)
+
+    return result
+
+
+def get_nested_models(model_class: Type[BaseModel]) -> list[NestedModel]:
+    """
+    Находит все атрибуты переданной модели, которые являются подклассами BaseModel.
+    Работает с Optional и Union типами.
+    """
+    result: list[NestedModel] = []
+
+    # Получаем аннотации типов для всех атрибутов модели
+    type_hints = get_type_hints(model_class)
+
+    for attr_name, attr_type in type_hints.items():
+        # Извлекаем модели из типа (обрабатывая Optional/Union)
+        models = extract_model_from_type(attr_type)
+
+        # Добавляем каждую найденную модель в результат
+        for model in models:
+            result.append(NestedModel(model=model, field_name=attr_name))
+
+    return result

niceforms/widget/__init__.py

@@ -0,0 +1,104 @@
+"""Виджеты для полей формы."""
+
+import logging
+from abc import ABC, abstractmethod
+from typing import Any, Optional
+
+from nicegui import ui
+from nicegui.elements.button import Button
+from nicegui.elements.mixins.value_element import ValueElement
+from pydantic.fields import FieldInfo
+from pydantic_core import PydanticUndefined
+
+from niceforms import UIComponent
+
+logger = logging.getLogger(__name__)
+
+
+class BaseWidget(UIComponent, ABC):
+    def __init__(
+        self,
+        field_info: FieldInfo,
+        field_name: str,
+        is_nullable: bool,
+        view_annotation_type: bool
+    ):
+        self.field = field_info
+        self.field_name = field_name
+        self.is_nullable = is_nullable
+        self.view_annotation_type = view_annotation_type
+
+        self.set_none_button: Optional[Button] = None
+
+    @property
+    def placeholder(self) -> str:
+        return (
+            f"Введите {self.field.title.lower()}"
+            if self.field.title
+            else "Введите значение"
+        )
+
+    @property
+    def default_value(self) -> Optional[Any]:
+        return (
+            self.field.default if self.field.default is not PydanticUndefined else None
+        )
+
+    def render_label(self) -> None:
+        text = self.field.title if self.field.title else self.field_name.title()
+        logger.debug(f"render label: {text}")
+
+        with ui.row().classes('mb-1 items-baseline justify-between w-full gap-1'):
+            with ui.row().classes('items-baseline gap-1'):
+                ui.label(text=text).classes('font-bold text-lg')
+                if self.field.is_required():
+                    ui.label(text='*').classes('text-gray-400 text-md font-normal')
+                if self.view_annotation_type:
+                    ui.label(text=f' [{self.field.annotation}]').classes(
+                        'text-gray-400 text-md font-normal'
+                    )
+
+            if self.is_nullable:
+
+                self.set_none_button = ui.button('Set None', color='secondary').classes(
+                    'text-xs opacity-70 hover:opacity-100 transition-opacity py-0.7 px-2 min-h-0 h-auto'
+                )
+
+        if self.field.description:
+            ui.label(text=self.field.description).classes("mb-1 text-gray-500")
+
+    @abstractmethod
+    def render(
+        self,
+    ) -> (
+        "RenderedWidget"
+    ):  # TODO: возможно достаточно будет в RenderedWidget передавать в место BaseWidget "field_name"
+        raise NotImplementedError
+
+
+class RenderedWidget(ABC):
+    def __init__(self, widget: BaseWidget, element: ValueElement) -> None:
+        self.widget = widget
+        self.element = element
+
+        self._none_is_set = False
+
+        if self.widget.set_none_button:
+
+            def on_click_set_none() -> None:
+                if self._none_is_set:
+                    self.widget.set_none_button.text = 'Set None'
+                    self._none_is_set = False
+                else:
+                    self.element.value = None
+                    self.widget.set_none_button.text = 'None is set'
+                    self._none_is_set = True
+
+            self.widget.set_none_button.on_click(on_click_set_none)
+
+    def clear(self) -> None:
+        self.element.set_value(None)
+
+    @abstractmethod
+    def collect(self) -> Optional[Any]:
+        raise NotImplementedError

niceforms/widget/bool.py

@@ -0,0 +1,27 @@
+from typing import Any, Optional
+
+from nicegui import ui
+
+from niceforms.widget import BaseWidget, RenderedWidget
+
+
+class RenderedBoolWidget(RenderedWidget):
+
+    def collect(self) -> Optional[Any]:
+        return self.element.value
+
+
+class BoolWidget(BaseWidget):
+
+    def render(self) -> RenderedBoolWidget:
+
+        checkbox = (
+            ui.checkbox(
+                text='Выставьте checkbox',
+                value=self.default_value,
+            )
+            .props("outlined dense")
+            .classes("w-full")
+        )
+
+        return RenderedBoolWidget(self, checkbox)

niceforms/widget/enum.py

@@ -0,0 +1,28 @@
+from typing import Any, Optional
+from enum import EnumMeta, Enum
+
+from nicegui import ui
+from pydantic_core import PydanticUndefinedType
+
+from niceforms.widget import BaseWidget, RenderedWidget
+
+
+class RenderedEnumWidget(RenderedWidget):
+
+    def collect(self) -> Optional[Any]:
+        return self.element.value
+
+
+class EnumWidget(BaseWidget):
+    """Виджет для полей типа Enum с выплывающим списком"""
+
+    def render(self) -> RenderedEnumWidget:
+        options = list(self.field.annotation) # type: ignore
+
+        s = ui.select(
+            label='Выберите значение',
+            value=self.default_value,
+            options=options,
+        ).props("outlined dense").classes("w-full")
+
+        return RenderedEnumWidget(self, s)

niceforms/widget/float.py

@@ -0,0 +1,28 @@
+from typing import Optional
+
+from nicegui import ui
+
+from niceforms.widget import BaseWidget, RenderedWidget
+
+
+class RenderedFloatWidget(RenderedWidget):
+
+    def collect(self) -> Optional[float]:
+        if self.element.value is None:
+            return None
+
+        return self.element.value
+
+
+class FloatWidget(BaseWidget):
+    def render(self) -> RenderedWidget:
+        el = (
+            ui.number(
+                value=self.default_value,
+                placeholder=self.placeholder,
+            )
+            .props("outlined dense")
+            .classes("w-full")
+        )
+
+        return RenderedFloatWidget(self, el)

niceforms/widget/integer.py

@@ -0,0 +1,25 @@
+from typing import Optional
+
+from nicegui import ui
+from pydantic_core import PydanticUndefinedType
+
+from niceforms.widget import BaseWidget, RenderedWidget
+
+
+class RenderedIntegerWidget(RenderedWidget):
+
+    def collect(self) -> Optional[int]:
+        if self.element.value is None:
+            return None
+
+        return int(self.element.value)
+
+
+class IntegerWidget(BaseWidget):
+    def render(self) -> RenderedWidget:
+        el = ui.number(
+            value=self.default_value,
+            placeholder=self.placeholder,
+        ).props("outlined dense").classes("w-full")
+
+        return RenderedIntegerWidget(self, el)

niceforms/widget/list.py

@@ -0,0 +1,48 @@
+from typing import Any, Optional, Union, List
+from datetime import datetime
+import json
+from json import JSONDecodeError
+from nicegui import ui
+
+from niceforms.widget import BaseWidget, RenderedWidget
+from utils import normalize_type
+
+
+class RenderedListWidget(RenderedWidget):
+
+    def collect(self) -> Optional[Union[list, tuple]]:
+        if self.element.value is not None:
+            return json.loads(self.element.value)
+
+        return None
+
+
+class ListWidget(BaseWidget):
+    type_tip_map: dict[type, str] = {
+        List[str]: '["яблоко", "банан", "апельсин"]',
+        List[int]: '[423, 324, 983]',
+        list[str]: '["яблоко", "банан", "апельсин"]',
+        list[int]: '[423, 324, 983]',
+    }
+
+    def render(self) -> RenderedWidget:
+        default_value = json.dumps(self.default_value) if self.default_value is not None else None
+
+        el = (
+            ui.textarea(value=default_value, placeholder=self.placeholder)
+            .props("outlined dense")
+            .classes("w-full font-mono")
+        )
+        # Контейнер для лейбла и иконки
+        with ui.row().classes('items-center gap-1'):
+            ui.label(text=f'Строка парсится как JSON').classes('text-xs mt-1')
+            normalized_type = normalize_type(self.field.annotation)
+
+            example = self.type_tip_map.get(normalized_type.origin_type)
+            if example is not None:
+                # Иконка с подсказкой при наведении
+                ui.icon('info', size='xs').classes('cursor-help mt-1').tooltip(
+                    f'Пример ввода: {example}'
+                ).style('color: #8989ff')
+
+        return RenderedListWidget(self, el)

niceforms/widget/string.py

@@ -0,0 +1,22 @@
+from typing import Any, Optional
+
+from nicegui import ui
+from pydantic_core import PydanticUndefinedType
+
+from niceforms.widget import BaseWidget, RenderedWidget
+
+
+class RenderedStringWidget(RenderedWidget):
+
+    def collect(self) -> Optional[str]:
+        if self.element.value == '':
+            return None
+
+        return self.element.value
+
+
+class StringWidget(BaseWidget):
+
+    def render(self) -> RenderedWidget:
+        el = ui.input(value=self.default_value, placeholder=self.placeholder).props("outlined dense").classes("w-full")
+        return RenderedStringWidget(self, el)

niceforms/widget/unknown_type.py

@@ -0,0 +1,33 @@
+from typing import Optional
+
+from nicegui import ui
+from pydantic_core import PydanticUndefinedType
+
+from niceforms.widget import BaseWidget, RenderedWidget
+
+
+class RenderedUnknownTypeWidget(RenderedWidget):
+
+    def collect(self) -> Optional[int]:
+        return self.element.value
+
+
+class UnknownTypeWidget(BaseWidget):
+    """Для неизвестных типов предлагается вводить JSON строку"""
+
+    def render(self) -> RenderedWidget:
+        el = (
+            ui.input(
+                value=self.default_value,
+                placeholder=self.placeholder,
+                # on_change=self._validate_json,
+            )
+            .classes('w-full font-mono')
+            .props("outlined dense")
+        )
+
+        ui.label(
+            text=f'Для типа "{self.field.annotation}" не существует виджета. Предоставлен обычный ввод строки.'
+        ).classes('text-xs mt-1').style('color: #ff3a3a')
+
+        return RenderedUnknownTypeWidget(self, el)

niceforms/widget_factory.py

@@ -0,0 +1,68 @@
+import logging
+from enum import Enum
+from typing import List
+
+from pydantic.fields import FieldInfo
+
+from utils import normalize_type, is_enum_type
+from widget.bool import BoolWidget
+from widget.enum import EnumWidget
+from widget.float import FloatWidget
+from widget.integer import IntegerWidget
+from widget.list import ListWidget
+from widget.string import StringWidget
+from widget import BaseWidget
+from widget.unknown_type import UnknownTypeWidget
+
+logger = logging.getLogger(__name__)
+
+
+class WidgetFactory:
+    def __init__(self) -> None:
+        self._widgets: dict[type, type[BaseWidget]] = {
+            str: StringWidget,
+            int: IntegerWidget,
+            int | None: IntegerWidget,
+            Enum: EnumWidget,
+            bool: BoolWidget,
+            float: FloatWidget,
+            list[str]: ListWidget,
+            List[str]: ListWidget,
+            list[int]: ListWidget,
+            List[int]: ListWidget,
+        }
+
+    def insert_new_widget(
+        self, field_type: type, widget_type: type[BaseWidget]
+    ) -> None:
+        self._widgets[field_type] = widget_type
+
+    def build(self, model_fields: dict[str, FieldInfo], view_annotation_type: bool) -> list[BaseWidget]:
+        widgets: list[BaseWidget] = []
+
+        for field_name, field_type in model_fields.items():
+            normalized_type = normalize_type(field_type.annotation)
+            try:
+                widget = self._widgets[field_type.annotation]
+            except KeyError:
+                widget = self._widgets.get(normalized_type.origin_type)
+
+            if is_enum_type(normalized_type.origin_type):
+                widget = self._widgets[Enum]
+
+            if widget is None:
+                logger.warning(
+                    f'No widget for field "{field_name}". Type {field_type.annotation}. Creating default <UnknownTypeWidget>'
+                )
+                widget = UnknownTypeWidget
+
+            widgets.append(
+                widget(
+                    field_info=field_type,
+                    field_name=field_name,
+                    is_nullable=normalized_type.is_nullable,
+                    view_annotation_type=view_annotation_type
+                )
+            )
+
+        return widgets

niceforms-0.1.0.dist-info/METADATA

@@ -0,0 +1,20 @@
+Metadata-Version: 2.4
+Name: niceforms
+Version: 0.1.0
+Summary: A dynamic form generator for NiceGUI that automatically creates interactive UI forms from Pydantic models
+Author: pasha_danilevich
+Author-email: danilevitch.pasha@yandex.ru
+Requires-Python: >=3.10,<4
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: nicegui (>=3.6.1,<4.0.0)
+Requires-Dist: pydantic (>=2.12.5,<3.0.0)
+Description-Content-Type: text/markdown
+
+# niceforms
+A dynamic form generator for NiceGUI that automatically creates interactive UI forms from Pydantic models.
+

niceforms-0.1.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+niceforms/__init__.py,sha256=CrTbKZAwPT2u5CH-YMkzkIPFzSDvHsqtmZnoi50bx8w,2803
+niceforms/actions.py,sha256=4TajbnXcfvb24yAaS85foOns3wyTyTQE1ea3pO4hets,149
+niceforms/constants.py,sha256=Vzyj_lII5t9pNp6NDN3QL48a28LR5NpmBDb6E2AD4kU,410
+niceforms/ui/__init__.py,sha256=3SixxiIXIqOr3ZPfTLzdPCG51pnZ0Tc9uvoolzT1RBE,289
+niceforms/ui/body.py,sha256=5rmOIWj6fk-AINYAZe83SnaKnb3EeEHRRC340CSXCMU,626
+niceforms/ui/footer.py,sha256=CX8UxnEwLPo20JjUcbC9m9CX1xZUPpEuwXa_48PxNnw,2547
+niceforms/ui/header.py,sha256=pVt45FCttZbSC9fERyC7g3jR2DOTRrVUX35YFZGVYqs,1991
+niceforms/ui/json_viewer.py,sha256=hUhaf34Ip0eN7BIH9uTej6KBScFI0OiVwh99f024sh0,797
+niceforms/utils.py,sha256=KzZNnmXvFmrF_S0BifNA0e7s7pYSuLdtjGCymuHblKA,3342
+niceforms/widget/__init__.py,sha256=H-rT7V1ZcjufUh2zUnlyEaq_-wXltYmWD5LI7iAYqGU,3406
+niceforms/widget/bool.py,sha256=1ofP2sHfCLVx2ciYtZCZS1I9EkSrEkOZm0-GZqRVBos,594
+niceforms/widget/enum.py,sha256=jN11XocYOL186FFOIU57clIMrzyZ5ZchyD1zHY7IwIQ,789
+niceforms/widget/float.py,sha256=93ZHHnFk1YtR9vElTQpqH6S46vlaIS_fZfK3zdRAqpg,632
+niceforms/widget/integer.py,sha256=Eh5KsYfg2_mHR8IgclQAhGrvk5DEQHcdkhHQhDKmvCg,627
+niceforms/widget/list.py,sha256=LRLSuLjCM1_JnDKuEIV6wwYOkFzro4nV5C-JaNMgx5Q,1763
+niceforms/widget/string.py,sha256=hEDVFfr4cynb4a9Jr5wyaJwr04L-gJDfMa1RRtvVRPM,586
+niceforms/widget/unknown_type.py,sha256=Qbob229ylW1XQW_WQioh5TQdfMjykPhQsfjauJVgU9c,1044
+niceforms/widget_factory.py,sha256=2Ux4QtwN7M2gV5TwW4GKL7DPqyJ3aHz_WnVnXfa13Io,2223
+niceforms-0.1.0.dist-info/METADATA,sha256=7u6fmgykJBba54IBxEgnBVKSA3fTuSQw3-5auEWyx8c,808
+niceforms-0.1.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+niceforms-0.1.0.dist-info/RECORD,,

niceforms-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.2.1
+Root-Is-Purelib: true
+Tag: py3-none-any