dearpygui-forms 0.1.3__tar.gz → 0.2.1__tar.gz

{dearpygui_forms-0.1.3 → dearpygui_forms-0.2.1}/.gitignore

@@ -10,5 +10,6 @@ wheels/
 .venv
 
 # Project-specific files
+.env
 data/
 *.ini

dearpygui_forms-0.2.1/.python-version

@@ -0,0 +1 @@
+3.10

dearpygui_forms-0.2.1/PKG-INFO

@@ -0,0 +1,64 @@
+Metadata-Version: 2.4
+Name: dearpygui-forms
+Version: 0.2.1
+Summary: Dearpygui extention for autogeneration forms powered by pydantic.
+Project-URL: homepage, https://github.com/vlewicki/dearpygui-forms
+Author-email: Valentin Lewicki <vlewicki@vlewicki.ru>
+Requires-Python: >=3.10
+Requires-Dist: dearpygui>=2.0.0
+Requires-Dist: loguru>=0.7.3
+Requires-Dist: pydantic>=2.11.7
+Description-Content-Type: text/markdown
+
+# DearPyGui Forms
+Generate GUI forms for your Pydantic models.
+
+## Features
+- Fill form fields with Pydantic model data
+- Fill from fields with default values
+- Validation on form submission
+- Callbacks for form submission
+
+
+Currently supported Pydantic fields:
+- str
+- int
+- float
+- bool
+- datetime
+- date
+- time
+
+## Example:
+```python
+from pprint import pprint
+import dearpygui.dearpygui as dpg
+from pydantic import BaseModel, Field
+from dearpygui_forms import DPGForm
+
+class User(BaseModel):
+    name: str = Field(default="John Doe", min_length=3)
+    age: int = Field(ge=18)
+
+
+class Storage(BaseModel):
+    users: list[User] = []
+
+class UserForm(DPGForm, model=User):
+    pass
+
+
+dpg.create_context()
+dpg.create_viewport()
+
+store = Storage()
+
+with dpg.window(label="User Form"):
+    user_form = UserForm(callback=lambda x: store.users.append(x))
+    user_form.add()
+    dpg.add_button(label="Print Users", callback=lambda: pprint(store.model_dump()))
+dpg.setup_dearpygui()
+dpg.show_viewport()
+dpg.start_dearpygui()
+dpg.destroy_context()
+```

dearpygui_forms-0.2.1/README.md

@@ -0,0 +1,52 @@
+# DearPyGui Forms
+Generate GUI forms for your Pydantic models.
+
+## Features
+- Fill form fields with Pydantic model data
+- Fill from fields with default values
+- Validation on form submission
+- Callbacks for form submission
+
+
+Currently supported Pydantic fields:
+- str
+- int
+- float
+- bool
+- datetime
+- date
+- time
+
+## Example:
+```python
+from pprint import pprint
+import dearpygui.dearpygui as dpg
+from pydantic import BaseModel, Field
+from dearpygui_forms import DPGForm
+
+class User(BaseModel):
+    name: str = Field(default="John Doe", min_length=3)
+    age: int = Field(ge=18)
+
+
+class Storage(BaseModel):
+    users: list[User] = []
+
+class UserForm(DPGForm, model=User):
+    pass
+
+
+dpg.create_context()
+dpg.create_viewport()
+
+store = Storage()
+
+with dpg.window(label="User Form"):
+    user_form = UserForm(callback=lambda x: store.users.append(x))
+    user_form.add()
+    dpg.add_button(label="Print Users", callback=lambda: pprint(store.model_dump()))
+dpg.setup_dearpygui()
+dpg.show_viewport()
+dpg.start_dearpygui()
+dpg.destroy_context()
+```

{dearpygui_forms-0.1.3 → dearpygui_forms-0.2.1}/pyproject.toml

@@ -1,20 +1,20 @@
 [project]
 name = "dearpygui-forms"
-version = "0.1.3"
+version = "0.2.1"
 description = "Dearpygui extention for autogeneration forms powered by pydantic."
 readme = "README.md"
 authors = [
     { name = "Valentin Lewicki", email = "vlewicki@vlewicki.ru" }
 ]
-requires-python = ">=3.13"
+requires-python = ">=3.10"
 dependencies = [
     "dearpygui>=2.0.0",
     "loguru>=0.7.3",
     "pydantic>=2.11.7",
 ]
 
-[project.scripts]
-dearpygui-forms = "dearpygui_forms:main"
+[project.urls]
+homepage = "https://github.com/vlewicki/dearpygui-forms"
 
 
 [build-system]
@@ -25,6 +25,3 @@ build-backend = "hatchling.build"
 dev = [
     "pylint>=3.3.7",
 ]
-
-[tools.hatch.build]
-include = ["src", "README.md"]

dearpygui_forms-0.2.1/src/dearpygui_forms/__init__.py

@@ -0,0 +1,4 @@
+"""
+Dearpygui extention for autogeneration forms powered by pydantic.
+"""
+from .dpg_form import DPGForm

dearpygui_forms-0.2.1/src/dearpygui_forms/dpg_form.py

@@ -0,0 +1,57 @@
+from pprint import pformat
+from typing import Any, Type
+import copy
+
+import pydantic
+import dearpygui.dearpygui as dpg
+from loguru import logger
+
+
+from .models import PropertySchema
+from .widgets import *
+from . import exceptions
+
+
+def extract_defs(schema: dict[str, Any]) -> tuple[dict[str, Any], dict[str, Any]]:
+    """split schema on root models schema and $defs"""
+    schema = copy.deepcopy(schema)
+    if "$defs" in schema:
+        defs = schema["$defs"]
+        del schema["$defs"]
+        root_model_schema =  schema
+    else:
+        defs = {}
+        root_model_schema = schema
+    return root_model_schema, defs
+
+
+class DPGForm:
+    def __init_subclass__(cls, *, model: Type[pydantic.BaseModel]) -> None:
+        cls._Model = model
+
+    def __init__(self, callback):
+        model_schema, models_defs = extract_defs(self._Model.model_json_schema())
+        self._model_widget = generate_widget(model_schema, models_defs)
+        self._callback = callback
+
+    def add(self):
+        self._model_widget.add()
+        dpg.add_button(label="Submit", callback=self._on_submit)
+
+    def fill_form(self, data_model: pydantic.BaseModel):
+        self._model_widget.set_value(data_model.model_dump())
+
+    def _on_submit(self):
+        try:
+            data = self._Model(**self._model_widget.get_value())
+        except pydantic.ValidationError as e:
+            with dpg.window(modal=True, label="Validation Error"):
+                dpg.add_text(f"Validation error: {e}")
+        except exceptions.DearpyguiFormsError as e:
+            with dpg.window(modal=True, label="Form Error"):
+                dpg.add_text(f"Form error: {e}")
+        else:
+            self._callback(data)
+
+    def get_form_data(self):
+        return self._Model(**self._model_widget.get_value())

dearpygui_forms-0.2.1/src/dearpygui_forms/exceptions.py

@@ -0,0 +1,2 @@
+class DearpyguiFormsError(Exception):
+    pass

dearpygui_forms-0.2.1/src/dearpygui_forms/models.py

@@ -0,0 +1,14 @@
+from typing import Any, Literal
+from pydantic import BaseModel
+
+
+class PropertySchema:
+    def __init__(self, schema: dict[str, Any]) -> None:
+        self.title: str | None = schema.get("title", None)
+        self.type: str | None = schema.get("type", None)
+        self.anyOf: list[dict[str, Any]] = schema.get("anyOf", [])
+        self.properties: dict[str, dict[str, Any]] = schema.get("properties", {})
+        self.default = schema.get("default", None)
+
+    def __repr__(self) -> str:
+        return f"PropertySchema(title={self.title}, type={self.type}, anyOf={self.anyOf}, properties={self.properties}, default={self.default})"

dearpygui_forms-0.2.1/src/dearpygui_forms/widgets.py

@@ -0,0 +1,256 @@
+import copy
+from typing import Any
+
+import dearpygui.dearpygui as dpg
+from loguru import logger
+
+
+from .models import PropertySchema
+from .exceptions import DearpyguiFormsError
+
+
+@logger.catch
+def dereference_property(schema: dict[str, Any], defs: dict[str, Any]):
+    if "$ref" in schema:
+        path = schema["$ref"].split("/")[-1]
+        new_schema = copy.deepcopy(defs[path])
+        new_schema.update(copy.deepcopy(schema))
+        del new_schema["$ref"]
+    else:
+        new_schema = copy.deepcopy(schema)
+    return new_schema
+
+
+class Widget:
+    def __init__(self, schema: PropertySchema, defs: dict, **kwargs):
+        self.schema = schema
+        self._defs = defs
+        self._kwargs = kwargs
+        with dpg.stage() as self._staging_container_id:
+            with dpg.group() as self._root_item:
+                self._ui()
+
+        if schema.default:
+            self.set_value(schema.default)
+
+    def _ui(self):
+        dpg.add_text(f"Property {self.schema.title}, type: {self.schema.type}")
+
+    def add(self, parent=None, hidden=False):
+        """
+        Add widget as dpg ui item.
+        """
+        if parent is not None:
+            dpg.push_container_stack(parent)
+            dpg.unstage(self._staging_container_id)
+            dpg.pop_container_stack()
+        else:
+            dpg.unstage(self._staging_container_id)
+
+        if hidden:
+            self.hide()
+
+    def hide(self):
+        dpg.hide_item(self._root_item)
+
+    def show(self):
+        dpg.show_item(self._root_item)
+
+    def set_value(self, value: Any):
+        pass
+
+    def get_value(self) -> Any:
+        pass
+
+
+class ObjectWidget(Widget):
+    def __init__(self, schema, defs, **kwargs):
+        self._properties: dict[str, Widget] = {}
+        super().__init__(schema, defs, **kwargs)
+
+    def _ui(self):
+        for property_name, property in self.schema.properties.items():
+            property_widget = generate_widget(property, self._defs, generate_object=False)
+            property_widget.add()
+            self._properties[property_name] = property_widget
+
+    def get_value(self) -> dict[str, Any]:
+        return {property_name: property_widget.get_value() for property_name, property_widget in self._properties.items()}
+
+    def set_value(self, value: dict[str, Any]):
+        for property_name, property_widget in self._properties.items():
+            property_widget.set_value(value.get(property_name))
+
+
+class ArrayWidget(Widget):
+    def __init__(self, schema, defs, **kwargs):
+        super().__init__(schema, defs, **kwargs)
+
+
+class MultiTypeWidget(Widget):
+    def __init__(self, schema, defs, **kwargs):
+        self._type_switcher_id = dpg.generate_uuid()
+        self._widget: Widget | None = None
+        self._widgets: dict[str, Widget] = {}
+        for type_schema in schema.anyOf:
+            widget = generate_widget(type_schema, defs, generate_object=False)
+            self._widgets[widget.schema.type] = widget
+
+        super().__init__(schema, defs, **kwargs)
+
+    def _ui(self):
+        with dpg.group(horizontal=True):
+            dpg.add_text(self.schema.title)
+            dpg.add_combo(label="Type",
+                tag=self._type_switcher_id,
+                items=list(self._widgets.keys()),
+                callback=self.switch_value_type,
+                no_preview=True
+            )
+        with dpg.group(indent=25) as self._form:
+            for widget in self._widgets.values():
+                widget.add(hidden=True)
+
+    def switch_value_type(self):
+        new_type = dpg.get_value(self._type_switcher_id)
+        if self._widget is not None:
+            self._widget.hide()
+        self._widget = self._widgets[new_type]
+        self._widget.show()
+
+    def get_value(self):
+        if self._widget:
+            return self._widget.get_value()
+        else:
+            raise DearpyguiFormsError(f"{self.schema.title}: choose value type")
+
+    def set_value(self, value):
+        pass
+        # dpg.set_value(self._type_switcher_id, value)
+
+
+class StringWidget(Widget):
+    def __init__(self, schema, defs, **kwargs):
+        self._input_id = dpg.generate_uuid()
+        super().__init__(schema, defs, **kwargs)
+
+    def _ui(self):
+        dpg.add_input_text(label=self.schema.title, tag=self._input_id)
+
+    def get_value(self):
+        return dpg.get_value(self._input_id)
+
+    def set_value(self, value):
+        dpg.set_value(self._input_id, value)
+
+
+class IntegerWidget(Widget):
+    def __init__(self, schema, defs, **kwargs):
+        self._input_id = dpg.generate_uuid()
+        super().__init__(schema, defs, **kwargs)
+
+    def _ui(self):
+        dpg.add_input_int(label=self.schema.title, tag=self._input_id)
+
+    def get_value(self):
+        return dpg.get_value(self._input_id)
+
+    def set_value(self, value):
+        dpg.set_value(self._input_id, value)
+
+
+class NumberWidget(Widget):
+    def __init__(self, schema, defs, **kwargs):
+        self._input_id = dpg.generate_uuid()
+        super().__init__(schema, defs, **kwargs)
+
+    def _ui(self):
+        dpg.add_input_float(label=self.schema.title, tag=self._input_id)
+
+    def get_value(self):
+        return dpg.get_value(self._input_id)
+
+    def set_value(self, value):
+        dpg.set_value(self._input_id, value)
+
+
+class BooleanWidget(Widget):
+    def __init__(self, schema, defs, **kwargs):
+        self._checkbox_id = dpg.generate_uuid()
+        super().__init__(schema, defs, **kwargs)
+
+    def _ui(self):
+       dpg.add_checkbox(label=self.schema.title, tag=self._checkbox_id)
+
+    def get_value(self):
+        return dpg.get_value(self._checkbox_id)
+
+    def set_value(self, value: bool):
+        dpg.set_value(self._checkbox_id, value)
+
+class NoneWidget(Widget):
+    def __init__(self, schema, defs, **kwargs):
+        self._none_id = dpg.generate_uuid()
+        super().__init__(schema, defs, **kwargs)
+
+    def _ui(self):
+        dpg.add_input_text(default_value='<None>', label=self.schema.title, tag=self._none_id, enabled=False)
+
+    def get_value(self):
+        return None
+
+    def set_value(self, value):
+        pass
+
+
+class ExternalWidget(Widget):
+    def __init__(self, schema, defs, **kwargs):
+        self._external_id = dpg.generate_uuid()
+        self._widget: Widget | None = None
+        super().__init__(schema, defs, **kwargs)
+
+    def _ui(self):
+        with dpg.tree_node(label=self.schema.title) as self._form:
+            self._edit_button = dpg.add_button(label=f"Edit", callback=self.show_object_form)
+
+    def show_object_form(self):
+        if self._widget is None:
+            dpg.delete_item(self._edit_button)
+            self._widget = ObjectWidget(self.schema, self._defs)
+            self._widget.add(parent=self._form)
+
+    def get_value(self):
+        if self._widget is None:
+            raise DearpyguiFormsError(f"{self.schema.title}: set up object.")
+        return self._widget.get_value()
+
+    def set_value(self, value):
+        self.show_object_form()
+        self._widget.set_value(value)
+
+
+def generate_widget(json_schema: dict[str, Any],  defs: dict[str, Any], generate_object: bool = True, **kwargs) -> Widget:
+    schema = PropertySchema(dereference_property(json_schema, defs))
+    match schema:
+        case PropertySchema(type='object'):
+            if generate_object:
+                return ObjectWidget(schema, defs, **kwargs)
+            else:
+                return ExternalWidget(schema, defs, **kwargs)
+        case PropertySchema(type='array'):
+            raise NotImplementedError("ArrayWidget is not implemented yet")
+            return ArrayWidget(schema, defs, **kwargs)
+        case PropertySchema(type='string'):
+            return StringWidget(schema, defs, **kwargs)
+        case PropertySchema(type='integer'):
+            return IntegerWidget(schema, defs, **kwargs)
+        case PropertySchema(type='number'):
+            return NumberWidget(schema, defs, **kwargs)
+        case PropertySchema(type='boolean'):
+            return BooleanWidget(schema, defs, **kwargs)
+        case PropertySchema(type='null'):
+            return NoneWidget(schema, defs, **kwargs)
+        case PropertySchema(anyOf=types) if len(types) > 0:
+            return MultiTypeWidget(schema, defs, **kwargs)
+        case _:
+            raise ValueError(f"Unsupported schema: {schema}")

{dearpygui_forms-0.1.3 → dearpygui_forms-0.2.1}/tests/demo.py

@@ -1,8 +1,10 @@
 import datetime
 import decimal
+from pprint import pprint
 import dearpygui.dearpygui as dpg
 
 import dearpygui.dearpygui as dpg
+from loguru import logger
 from pydantic import BaseModel, Field
 
 from dearpygui import demo
@@ -10,6 +12,11 @@ import pydantic
 from dearpygui_forms import DPGForm
 
 
+class Tool(BaseModel):
+    name: str = Field(title="Tool name", min_length=1)
+    price: float = Field(title="Price", ge=0)
+    quantity: int = Field(title="Quantity", ge=0)
+
 class User(BaseModel):
     name: str = Field(title="User name", min_length=1)
     birthday: datetime.date = datetime.date(2000, 1, 1)
@@ -18,14 +25,18 @@ class User(BaseModel):
     fingers_on_the_hand: int = 5
     weight: float = 60.0
     pi: decimal.Decimal = decimal.Decimal('3.1415')
-    male: bool = True
+    male: bool|None = True
+    tool: Tool = Field(title="Gun", default=Tool(name="Gun00", price=100.0, quantity=1))
+    best_friend: 'User | None' = Field(title='Best friend')
+    zero: None
     # friends: list['User']
 
 
+class UserForm(DPGForm, model=User):
+    pass
 
-class UserForm(DPGForm):
-    __pydantic_model__ = User
-
+class ToolForm(DPGForm, model=Tool):
+    pass
 
 
 def main():
@@ -52,11 +63,7 @@ def main():
             dpg.add_menu_item(label='About', callback=dpg.show_about)
 
     with dpg.window(label="Template", width=641, height=480):
-        dpg.add_text("Hello")
-
-    with dpg.window(label="Main"):
-        dpg.add_text("Hello")
-        UserForm(print).add()
+        UserForm(lambda x: logger.success(x)).add()
 
 
 

dearpygui_forms-0.2.1/tests/micro_demo.py

@@ -0,0 +1,30 @@
+from pprint import pprint
+import dearpygui.dearpygui as dpg
+from pydantic import BaseModel, Field
+from dearpygui_forms import DPGForm
+
+class User(BaseModel):
+    name: str = Field(default="John Doe", min_length=3)
+    age: int = Field(ge=18)
+
+
+class Storage(BaseModel):
+    users: list[User] = []
+
+class UserForm(DPGForm, model=User):
+    pass
+
+
+dpg.create_context()
+dpg.create_viewport()
+
+store = Storage()
+
+with dpg.window(label="User Form"):
+    user_form = UserForm(callback=lambda x: store.users.append(x))
+    user_form.add()
+    dpg.add_button(label="Print Users", callback=lambda: pprint(store.model_dump()))
+dpg.setup_dearpygui()
+dpg.show_viewport()
+dpg.start_dearpygui()
+dpg.destroy_context()

dearpygui_forms-0.2.1/tests/test_models.py

@@ -0,0 +1,37 @@
+import enum
+from pprint import pprint
+from pydantic import BaseModel
+
+
+models: list[type[BaseModel]] = []
+
+
+class Category(enum.Enum):
+    FOOD = "food"
+    ENTERTAINMENT = "entertainment"
+    TRANSPORTATION = "transportation"
+    HOUSING = "housing"
+    UTILITIES = "utilities"
+    OTHER = 0
+
+class Transaction(BaseModel):
+    category: Category
+
+
+models.append(Transaction)
+
+class Test1(BaseModel):
+    val: int | None = None
+
+models.append(Test1)
+
+
+class Test2(BaseModel):
+    val: Transaction | Test1
+
+models.append(Test2)
+
+
+for model in models:
+    pprint(model.model_json_schema())
+    print(Test1().model_dump_json())