dearpygui-forms 0.1.2__py3-none-any.whl → 0.2.0__py3-none-any.whl

dearpygui_forms/__init__.py

@@ -1,124 +1,4 @@
 """
 Dearpygui extention for autogeneration forms powered by pydantic.
 """
-import decimal
-from typing import Any, Type
-from pprint import pformat
-
-
-import dearpygui.dearpygui as dpg
-from loguru import logger
-import pydantic
-
-
-def parse_property_type(property_schema: dict[str, Any]) -> str:
-    property_type = property_schema.get("type", None)
-    if property_type is None:
-        any_of = property_schema.get("anyOf", None)
-        if any_of is None:
-            raise ValueError(f"Property type not detected. {property_schema}")
-
-        # Text input field preferred for Decimal type than float input field
-        if 'string' in map(lambda x: x.get("type"), any_of):
-            property_type = 'string'
-        else:
-            property_type =  any_of[0].get("type", None)
-
-        if property_type is None:
-            raise ValueError(f"Property type not detected. {property_schema}")
-    return property_type
-
-class DPGForm:
-    """
-    Base class for dearpygui forms.
-    Sublasses must define `__pydantic_model__` with some Pydantic model type.
-
-    # Example:
-    ```python
-    import dearpygui.dearpygui as dpg
-    from pydantic import BaseModel
-    from dearpygui_forms import DPGForm
-
-    class User(BaseModel):
-        name: str
-        age: int
-
-    class UserForm(DPGForm):
-        __pydantic_model__ = User
-
-    dpg.create_context()
-    dpg.create_viewport()
-    with dpg.window(label="User Form"):
-        user_form = UserForm(callback=lambda x: print(x))
-        user_form.add()
-    dpg.setup_dearpygui()
-    dpg.show_viewport()
-    dpg.start_dearpygui()
-    dpg.destroy_context()
-    ```
-    """
-    __pydantic_model__: Type[pydantic.BaseModel]
-
-    def __init__(self, callback):
-        """
-        Initializes the UserForm instance.
-
-        Args:
-            callback (Callable): The callback function to be called with a validated pydantic model.
-        """
-        self.callback = callback
-        logger.debug(self.__pydantic_model__)
-        self.model_schema = self.__pydantic_model__.model_json_schema()
-        logger.debug(pformat(self.model_schema))
-
-    def add(self):
-        """Adds form as child_window dearpygui element."""
-        schema = self.model_schema
-        with dpg.child_window(label=schema["title"]):
-            for property_name, property_schema in schema["properties"].items():
-                property_type = parse_property_type(property_schema)
-                default_value = property_schema.get("default")
-                if property_type == "string":
-                    schema["properties"][property_name]["dpg_form_id"] = \
-                    dpg.add_input_text(label=property_schema["title"], default_value=default_value or '')
-                elif property_type == "integer":
-                    schema["properties"][property_name]["dpg_form_id"] = \
-                    dpg.add_input_int(label=property_schema["title"], default_value=default_value)
-                elif property_type == "number":
-                    schema["properties"][property_name]["dpg_form_id"] = \
-                    dpg.add_input_float(label=property_schema["title"], default_value=float(default_value))
-                elif property_type == "boolean":
-                    schema["properties"][property_name]["dpg_form_id"] = \
-                    dpg.add_checkbox(label=property_schema["title"], default_value=default_value)
-                elif property_type == "array":
-                    schema["properties"][property_name]["dpg_form_id"] = \
-                    dpg.add_input_text(label=property_schema["title"])
-                elif property_type == "object":
-                    schema["properties"][property_name]["dpg_form_id"] = \
-                    dpg.add_input_text(label=property_schema["title"])
-                else:
-                    raise ValueError(f"Unsupported type: {property_type}")
-
-            dpg.add_button(label="Submit", callback=self.submit)
-
-        logger.debug(pformat(self.model_schema))
-
-    def submit(self):
-        try:
-            data = self._handle_data()
-        except pydantic.ValidationError as e:
-            with dpg.window(label="Validation error", modal=True):
-                dpg.add_text(str(e))
-        else:
-            self.callback(data)
-
-    def _handle_data(self):
-        json_data = {}
-        for property_name, property_schema in self.model_schema["properties"].items():
-            form_id = property_schema["dpg_form_id"]
-            if form_id is not None:
-                json_data[property_name] = dpg.get_value(form_id)
-            else:
-                raise ValueError(f"Missing form ID for property: {property_name}")
-
-        return self.__pydantic_model__(**json_data)
+from .dpg_form import DPGForm

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/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/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.2.0.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,7 @@
+dearpygui_forms/__init__.py,sha256=G_SP5hMol1eeOBLl0Lsphe1yyQ800aaCzI0gp03UagE,104
+dearpygui_forms/dpg_form.py,sha256=hFSWL3BSc0sxVbA2b-_GLGUPIld1VXkGwImQVs8j3nE,1591
+dearpygui_forms/models.py,sha256=74CL8WvfY5Qrh-Fx1uSmRU-TY33r_LtFtS1unYqWI5M,636
+dearpygui_forms/widgets.py,sha256=hZsepjOtJtMloNeOaNVgAzNaTeZoznfPNwS7gnstLyw,6851
+dearpygui_forms-0.2.0.dist-info/METADATA,sha256=MDdweUUm5niI4vdOvI5b7YRSpB_ss4VS7C1a9Ls01MA,1457
+dearpygui_forms-0.2.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+dearpygui_forms-0.2.0.dist-info/RECORD,,

dearpygui_forms-0.1.2.dist-info/METADATA

@@ -1,9 +0,0 @@
-Metadata-Version: 2.4
-Name: dearpygui-forms
-Version: 0.1.2
-Summary: Dearpygui extention for autogeneration forms powered by pydantic.
-Author-email: Valentin Lewicki <vlewicki@vlewicki.ru>
-Requires-Python: >=3.13
-Requires-Dist: dearpygui>=2.0.0
-Requires-Dist: loguru>=0.7.3
-Requires-Dist: pydantic>=2.11.7

dearpygui_forms-0.1.2.dist-info/RECORD

@@ -1,5 +0,0 @@
-dearpygui_forms/__init__.py,sha256=nZAlaoWBB-tBVnJxsJzMYtSqRqk6f92Gjx3oEVgIYPI,4687
-dearpygui_forms-0.1.2.dist-info/METADATA,sha256=8vuGAlFk6-wkpqYomj5N4YS9sZrzQTVUtEMz_k2bB98,305
-dearpygui_forms-0.1.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-dearpygui_forms-0.1.2.dist-info/entry_points.txt,sha256=7Iv9K4ckShx5C5O1M7Ta6zoIN9HUBBa7vHllqm2kvDQ,57
-dearpygui_forms-0.1.2.dist-info/RECORD,,

dearpygui_forms-0.1.2.dist-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-dearpygui-forms = dearpygui_forms:main