niceforms 0.1.1__tar.gz

niceforms-0.1.1/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.4
+Name: niceforms
+Version: 0.1.1
+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.1/README.md

@@ -0,0 +1,2 @@
+# niceforms
+A dynamic form generator for NiceGUI that automatically creates interactive UI forms from Pydantic models.

niceforms-0.1.1/niceforms/__init__.py

@@ -0,0 +1,104 @@
+import logging
+from pprint import pprint
+from typing import Optional, Type
+
+from actions import OnSubmit
+from constants import *
+from nicegui import ui
+from pydantic import BaseModel
+from pydantic.fields import FieldInfo
+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,
+        view_clear_button: bool = True,
+        view_json_button: 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
+        self.view_clear_button = view_clear_button
+        self.view_json_button = view_json_button
+
+        # style
+        self._card = None  # тело всей формы
+        self._is_nested = False
+
+    def render(self) -> None:
+        """Render the form UI."""
+        logger.debug(f"Rendering form {self.model.__name__}")
+        nested_models = get_nested_models(self.model)
+        print(f'{nested_models=}')
+        fields: dict[str, FieldInfo] = self.model.model_fields  # type: ignore
+        print(f'{fields=}')
+
+        for n_model in nested_models:
+            try:
+                del fields[n_model.field_name]
+                logger.debug(f'Field "{n_model.field_name}" is deleted')
+            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"p-2 w-full {DEFAULT_FORM_WIDTH} mx-auto shadow-lg rounded-xl overflow-hidden sm:p-4"
+        ) 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:
+
+                nested_form = BaseModelForm(
+                    model=n_model.model,
+                    header_bg_color='#2eeead',
+                    on_submit=None,
+                    view_json_button=False,
+                    view_annotation_type=self.view_annotation_type,
+                    view_clear_button=False,
+                )
+                nested_form._is_nested = True
+                nested_form.render()
+                nested_form._card.style('height: 100px')
+
+            if not self._is_nested:
+                Footer(
+                    elements=elements,
+                    model=self.model,
+                    on_submit=self.on_submit,
+                    view_clear_button=self.view_clear_button,
+                    view_json_button=self.view_json_button,
+                ).render()

niceforms-0.1.1/niceforms/actions.py

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

niceforms-0.1.1/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-0.1.1/niceforms/ui/__init__.py

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

niceforms-0.1.1/niceforms/ui/body.py

@@ -0,0 +1,19 @@
+from nicegui import ui
+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 space-y-3 p-1 sm:p-4"):
+            for w in self.widgets:
+                with ui.element().classes(f"w-full"):
+                    w.render_label()
+                    el = w.render()
+                    elements.append(el)
+
+        return elements

niceforms-0.1.1/niceforms/ui/footer.py

@@ -0,0 +1,78 @@
+import logging
+from typing import Any, Optional
+
+from actions import OnSubmit
+from nicegui import ui
+from nicegui.elements.button import Button
+from pydantic import BaseModel
+from ui.json_viewer import JsonDialog
+from widget import RenderedWidget
+
+from niceforms import PRIMARY_COLOR_GRADIENT, UIComponent
+
+logger = logging.getLogger(__name__)
+
+
+class Footer(UIComponent):
+    def __init__(
+        self,
+        elements: list[RenderedWidget],
+        model: type[BaseModel],
+        on_submit: Optional[OnSubmit],
+        view_clear_button: bool = True,
+        view_json_button: bool = True,
+    ) -> None:
+        self.elements = elements
+        self.model = model
+        self.on_submit = on_submit
+        self.view_clear_button = view_clear_button
+        self.view_json_button = view_json_button
+
+        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"):
+            if self.view_clear_button:
+                ui.button("Очистить", on_click=self.clear_form).props(
+                    "outlined flat"
+                ).classes("px-6 py-2")
+
+            if self.view_json_button:
+                ui.button(
+                    "Показать json", on_click=self.render_json_viewer_dialog
+                ).props("outlined flat").classes("px-6 py-2")
+
+            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-0.1.1/niceforms/ui/header.py

@@ -0,0 +1,67 @@
+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
+        self._description: Optional[Element] = None
+
+    def toggle_expand_parent(self) -> None:
+        if self._is_expanded:
+            self.parent_card.style('height: 100px')
+            self._is_expanded = False
+            self._button.text = 'Развернуть'
+            if self._description:
+                self._description.set_visibility(False)
+        else:
+            self.parent_card.style('height: 100%')
+            self._is_expanded = True
+            self._button.text = 'Свернуть'
+            if self._description:
+                self._description.set_visibility(True)
+
+    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:
+                self._description = (
+                    ui.label(self.description).classes("mt-2").style('color: #ffffff')
+                )
+                if self.is_nested:
+                    self._description.set_visibility(False)

niceforms-0.1.1/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-0.1.1/niceforms/utils.py

@@ -0,0 +1,95 @@
+import logging
+from enum import Enum
+from types import NoneType, UnionType
+from typing import Any, Type, Union, get_args, get_origin, get_type_hints
+
+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-0.1.1/niceforms/widget/__init__.py

@@ -0,0 +1,93 @@
+"""Виджеты для полей формы."""
+
+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
+from utils import NormalizedType
+
+logger = logging.getLogger(__name__)
+
+
+class BaseWidget(UIComponent, ABC):
+    def __init__(
+        self,
+        field_info: FieldInfo,
+        field_name: str,
+        normalized_type: NormalizedType,
+        view_annotation_type: bool,
+    ):
+        self.field = field_info
+        self.field_name = field_name
+        self.normalized_type = normalized_type
+        self.view_annotation_type = view_annotation_type
+
+        self.clear_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'
+                    )
+
+            self.clear_button = (
+                ui.button(icon='close', color='secondary')
+                .props('flat dense round')
+                .classes('text-xs opacity-30 hover:opacity-80 transition-opacity')
+                .tooltip('Очистить')
+            )
+
+        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.widget.clear_button.on_click(self.clear)
+
+    def clear(self) -> None:
+        self.element.set_value(None)
+
+    @abstractmethod
+    def collect(self) -> Optional[Any]:
+        raise NotImplementedError

niceforms-0.1.1/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-0.1.1/niceforms/widget/enum.py

@@ -0,0 +1,31 @@
+from typing import Any, Optional
+
+from nicegui import ui
+
+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:
+        print(f'{self.field_name}: {self.normalized_type.origin_type}')
+        options = list(self.normalized_type.origin_type)
+
+        s = (
+            ui.select(
+                label='Выберите значение',
+                value=self.default_value,
+                options=options,
+            )
+            .props("outlined dense")
+            .classes("w-full")
+        )
+
+        return RenderedEnumWidget(self, s)

niceforms-0.1.1/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-0.1.1/niceforms/widget/integer.py

@@ -0,0 +1,29 @@
+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-0.1.1/niceforms/widget/list.py

@@ -0,0 +1,51 @@
+import json
+from datetime import datetime
+from json import JSONDecodeError
+from typing import Any, List, Optional, Union
+
+from nicegui import ui
+from utils import normalize_type
+
+from niceforms.widget import BaseWidget, RenderedWidget
+
+
+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-0.1.1/niceforms/widget/string.py

@@ -0,0 +1,26 @@
+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-0.1.1/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-0.1.1/niceforms/widget_factory.py

@@ -0,0 +1,69 @@
+import logging
+from enum import Enum
+from typing import List
+
+from pydantic.fields import FieldInfo
+from utils import is_enum_type, normalize_type
+from widget import BaseWidget
+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.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,
+                    normalized_type=normalized_type,
+                    view_annotation_type=view_annotation_type,
+                )
+            )
+
+        return widgets

niceforms-0.1.1/pyproject.toml

@@ -0,0 +1,35 @@
+[project]
+name = "niceforms"
+version = "0.1.1"
+description = "A dynamic form generator for NiceGUI that automatically creates interactive UI forms from Pydantic models"
+authors = [
+    {name = "pasha_danilevich", email = "danilevitch.pasha@yandex.ru"}
+]
+readme = "README.md"
+
+packages = [
+    {include = "niceforms"}
+]
+
+[tool.poetry.dependencies]
+python = ">=3.10, <4"
+pydantic = "^2.12.5"
+nicegui = "^3.6.1"
+
+
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[dependency-groups]
+dev = [
+    "pytest (>=9.0.2,<10.0.0)",
+    "black (>=26.3.1,<27.0.0)",
+    "gitprompter (>=0.2.0,<0.3.0)"
+]
+
+[tool.black]
+line-length = 88
+skip-string-normalization = true
+preview = true