dearpygui-forms 0.1.2__tar.gz → 0.2.0__tar.gz

{dearpygui_forms-0.1.2 → dearpygui_forms-0.2.0}/.gitignore

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

dearpygui_forms-0.2.0/.python-version

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

dearpygui_forms-0.2.0/PKG-INFO

@@ -0,0 +1,64 @@
+Metadata-Version: 2.4
+Name: dearpygui-forms
+Version: 0.2.0
+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.0/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.2 → dearpygui_forms-0.2.0}/pyproject.toml

@@ -1,20 +1,20 @@
 [project]
 name = "dearpygui-forms"
-version = "0.1.2"
+version = "0.2.0"
 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.0/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.0/src/dearpygui_forms/dpg_form.py

@@ -0,0 +1,53 @@
+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 *
+
+
+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}")
+        else:
+            self._callback(data)
+
+    def get_form_data(self):
+        return self._Model(**self._model_widget.get_value())

dearpygui_forms-0.2.0/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.0/src/dearpygui_forms/widgets.py

@@ -0,0 +1,216 @@
+import copy
+from typing import Any
+
+import dearpygui.dearpygui as dpg
+from loguru import logger
+
+
+from .models import PropertySchema
+
+
+@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:
+            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):
+        dpg.unstage(self._staging_container_id)
+
+    def set_value(self, value: Any):
+        pass
+
+    def get_value(self) -> Any:
+        pass
+
+
+
+class ObjectWidget(Widget):
+    def __init__(self, schema, defs, **kwargs):
+        self._properties = {}
+        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 = [generate_widget(type_schema, defs) for type_schema in schema.anyOf]
+        super().__init__(schema, defs, **kwargs)
+        logger.debug(defs)
+
+
+    def _ui(self):
+        dpg.add_text(self.schema.title)
+        with dpg.group(indent=10):
+            dpg.add_combo(label="Type", tag=self._type_switcher_id, items=tuple(x.schema.title or x.schema.type for x in self._widgets), callback=self.switch_value_type)
+
+
+    def switch_value_type(self, new_type):
+        logger.debug(f"Switching to type {dpg.get_value(self._type_switcher_id)}")
+
+
+    def get_value(self):
+        if self._widget:
+            return self._widget.get_value()
+        else:
+            return None
+
+    def set_value(self, value):
+        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()
+        super().__init__(schema, defs, **kwargs)
+
+    def _ui(self):
+        dpg.add_button(label=self.schema.title, tag=self._external_id, enabled=False)
+
+    def get_value(self):
+        return None
+
+    def set_value(self, value):
+        pass
+
+
+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:
+                raise NotImplementedError("ExternalWidget is not implemented yet")
+                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:
+            raise NotImplementedError("MultiTypeWidget is not implemented yet")
+            # return MultiTypeWidget(schema, defs, **kwargs)
+        case _:
+            raise ValueError(f"Unsupported schema: {schema}")

{dearpygui_forms-0.1.2 → dearpygui_forms-0.2.0}/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)
@@ -19,13 +26,17 @@ class User(BaseModel):
     weight: float = 60.0
     pi: decimal.Decimal = decimal.Decimal('3.1415')
     male: bool = True
+    tool: Tool | int
+    best_friend: 'User' = 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,11 @@ 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()
+        tf = ToolForm(lambda x: logger.success(x))
+        tf.add()
+        t = Tool(name='Tool', price=100.55, quantity=22)
+        tf.fill_form(t)
 
 
 

dearpygui_forms-0.2.0/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.0/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())