robotframework-dialogsplus 0.1.0__py3-none-any.whl

DialogsPlus/__init__.py

@@ -0,0 +1,5 @@
+# src/DialogsPlus/__init__.py
+
+from .dialogsplus import DialogsPlus
+
+__all__ = ["DialogsPlus"]  

DialogsPlus/dialogsplus.py

@@ -0,0 +1,90 @@
+from robot.api.deco import keyword
+import os
+from DialogsPlus.utils.config import DialogConfig
+from DialogsPlus.widgets.wrappers import ( GetValueFromUserDialog, 
+                                          ExecuteManualStepDialog, 
+                                          CountdownDialogRunner,
+                                          GetConfirmationFromUser, 
+                                          MultiValueInput,
+                                          ChooseFromFileDialog,
+                                          ChooseFolderDialog,
+                                          ConfirmWithCheckbox,
+                                          SelectOptionsWithCheckboxes)
+
+
+ROBOT_LIBRARY_SCOPE = 'SUITE'
+
+class DialogsPlus:
+
+    def __init__(self, config=None):
+    
+        if config and os.path.exists(config):
+            self.config = DialogConfig.from_yaml(config)
+        else:
+            self.config = DialogConfig()  # use defaults
+
+    
+    @keyword
+    def get_value_from_user(self, prompt="Enter value:", default=""):
+        return GetValueFromUserDialog.show(prompt,default,config=self.config)
+
+    @keyword
+    def run_manual_steps(self, steps):
+        ExecuteManualStepDialog.run_steps(steps, config=self.config)
+
+    @keyword
+    def count_down(self, seconds):
+        CountdownDialogRunner.show(int(seconds), config=self.config)
+            
+    @keyword
+    def get_confirmation(self, message):
+        return GetConfirmationFromUser.show(message=message,config=self.config)
+    
+    @keyword
+    def get_multi_value(self, fields, default=None):
+        fields_list = fields if isinstance(fields, list) else [fields]
+        calculated_height = 150 + (len(fields_list) * 40) + 60
+        #max_field_length = max(len(field) for field in fields_list)
+        max_field_length = 20
+        calculated_width = 300 + (max_field_length * 8)
+        self.config.height = calculated_height
+        self.config.width = calculated_width
+        return MultiValueInput.run_multival(fields=fields,defaults=default,config=self.config)
+    
+    @keyword
+    def choose_file(self, message="",  filetypes=None, multiple=False):
+        return ChooseFromFileDialog.show( message, filetypes, multiple, self.config)
+
+    @keyword
+    def choose_folder(self, message):
+        return ChooseFolderDialog.show(message, self.config)
+    
+
+    @keyword
+    def confirm_with_checkbox(self, message, checkbox_text="I agree"):
+        return ConfirmWithCheckbox.show(message, checkbox_text, self.config)
+    
+
+    @keyword
+    def select_options_with_checkboxes(self, message, options, defaults=None):
+        """Show multiple checkboxes and return selected options as dictionary."""
+        
+        options_list = options if isinstance(options, list) else options.split('|')
+        
+        # Base sizing
+        num_options = len(options_list)
+        max_option_length = max(len(opt) for opt in options_list)
+        message_length = len(message)
+        
+        # Height: base + checkboxes + some buffer
+        calculated_height = 180 + (num_options * 40)
+        
+        # Width: consider both message and longest option
+        width_from_message = min(600, max(300, message_length * 7))
+        width_from_options = max(300, 200 + (max_option_length * 8))
+        calculated_width = max(width_from_message, width_from_options)
+        
+        self.config.height = calculated_height
+        self.config.width = calculated_width
+        
+        return SelectOptionsWithCheckboxes.show(message, options, defaults, self.config)

DialogsPlus/utils/config.py

@@ -0,0 +1,83 @@
+# dialog_config.py
+
+import yaml
+
+class DialogConfig:
+    def __init__(
+        self,
+        title="Robot Framework",
+        width=400,
+        height=150,
+        theme="blue",
+        appearance_mode="system",
+
+        button_width=120,
+        button_height=32,
+        label_font=("Courier New", 16, "bold"),
+        entry_width= 200,
+        entry_height=28,
+        spacing=10,
+        button_fg_color="#06bdb1",
+        button_font=("Courier New", 16, "bold"),
+        label_text_color="white",
+        button_text_color="black",
+        button_hover_color="#57b7b0",
+        entry_font=("Courier New", 14),
+        entry_text_color="white",
+        entry_fg_color="#212121",
+        entry_border_color="#46fff4",
+        frame_fg_color = "transparent",
+        progress_bar_width = 300,
+        progress_bar_height = 12,
+        progress_bar_color = "#00c0b5",
+
+        
+    ):
+        self.title = title
+        self.width = width
+        self.height = height
+        self.theme = theme
+        self.appearance_mode = appearance_mode
+
+        self.button_width = button_width
+        self.button_height = button_height
+        self.label_font = label_font
+        self.entry_width = entry_width
+        self.entry_height = entry_height
+        self.spacing = spacing
+        self.button_fg_color=button_fg_color
+        self.button_font = button_font
+        self.label_text_color = label_text_color
+        self.button_text_color = button_text_color
+        self.button_hover_color = button_hover_color
+        self.entry_font = entry_font
+        self.entry_text_color = entry_text_color
+        self.entry_fg_color = entry_fg_color
+        self.entry_border_color = entry_border_color
+        self.frame_fg_color = frame_fg_color
+        self.progress_bar_width = progress_bar_width
+        self.progress_bar_height = progress_bar_height
+        self.progress_bar_color = progress_bar_color
+
+
+    @classmethod
+    def from_yaml(cls, path: str):
+        print(f"[DEBUG] Received config path: {path}")
+        with open(path, "r", encoding="utf-8") as f:
+            data = yaml.safe_load(f)
+
+        return cls(
+            title=data.get("title", "Dialog"),
+            width=data.get("width", 300),
+            height=data.get("height", 150),
+            theme=data.get("theme", "blue"),
+            appearance_mode=data.get("appearance_mode", "system"),
+
+            button_width=data.get("button_width", 120),
+            button_height=data.get("button_height", 32),
+            label_font=tuple(data.get("label_font", ("Arial", 12))),
+            entry_height=data.get("entry_height", 28),
+            entry_width=data.get("entry_width",60),
+            spacing=data.get("spacing", 10),
+            button_fg_color=data.get("button_fg_color", "#06bdb1")
+        )

DialogsPlus/widgets/base.py

@@ -0,0 +1,169 @@
+import customtkinter as ctk
+from customtkinter import BooleanVar, IntVar
+from DialogsPlus.utils.config import DialogConfig
+from tkinter import filedialog
+import os
+
+
+# Export for use in other modules
+__all__ = [
+    'BaseDialogRunner',
+    'BaseDialog',
+    'ctk',
+    'BooleanVar',
+    'filedialog',
+    'IntVar'
+]
+
+class BaseDialogRunner:
+    _theme_initialized = False
+    
+    @staticmethod
+    def _center_window(app, config):
+        app.update_idletasks()
+        
+        screen_width = app.winfo_screenwidth()
+        screen_height = app.winfo_screenheight()
+        
+        x = (screen_width - config.width) // 2
+        y = (screen_height - config.height) // 2       
+        app.geometry(f"{config.width}x{config.height}+{x}+{y}")
+    
+    @staticmethod
+    def create_app(config: DialogConfig):
+        # Initialize theme once on first dialog creation
+        if not BaseDialogRunner._theme_initialized:
+            ctk.set_appearance_mode(config.appearance_mode)
+            ctk.set_default_color_theme(config.theme)
+            BaseDialogRunner._theme_initialized = True
+        
+        app = ctk.CTk()
+        app.title(config.title)
+
+        icon_path = os.path.join(os.path.dirname(__file__), "assets", "robot.ico")
+        try:
+            app.iconbitmap(icon_path)
+        except (FileNotFoundError, Exception):
+            pass
+
+        BaseDialogRunner._center_window(app, config)
+        return app
+
+    @staticmethod
+    def run_dialog(ui_builder_func, config: DialogConfig):
+        app = BaseDialogRunner.create_app(config)
+        ui_builder_func(app)
+        app.mainloop()
+        
+        app.withdraw()
+        
+        try:
+            after_ids = app.tk.call('after', 'info')
+            for after_id in after_ids:
+                try:
+                    app.after_cancel(after_id)
+                except:
+                    pass
+        except:
+            pass
+        
+        app.update_idletasks()
+        
+        try:
+            app.quit()
+        except:
+            pass
+        
+        try:
+            app.destroy()
+        except:
+            pass
+
+
+class BaseDialog:
+    
+    def __init__(self, config=None):
+        self.config = config if config else DialogConfig()
+        self.result = {}
+    
+    def create_button(self, parent, text, command, **kwargs):
+        """Create a button with config styling"""
+        return ctk.CTkButton(
+            parent,
+            text=text,
+            command=command,
+            font=self.config.button_font,
+            fg_color=self.config.button_fg_color,
+            text_color=self.config.button_text_color,
+            hover_color=self.config.button_hover_color,
+            width=kwargs.get('width', self.config.button_width),
+            height=kwargs.get('height', self.config.button_height),
+            **{k: v for k, v in kwargs.items() if k not in ['width', 'height']}
+        )
+
+    def create_label(self, parent, text, **kwargs):
+        """Create a label with config styling"""
+        return ctk.CTkLabel(
+            parent,
+            text=text,
+            font=self.config.label_font,
+            text_color=self.config.label_text_color,
+            anchor=kwargs.get('anchor', "center"),
+            justify=kwargs.get('justify', "left"),
+            wraplength=kwargs.get('wraplength', 0),
+            **{k: v for k, v in kwargs.items() if k not in ['anchor', 'justify', 'wraplength']}
+        )
+    
+    def create_entry(self, parent, **kwargs):
+        """Create an entry with consistent styling from config"""
+        return ctk.CTkEntry(
+            parent,
+            width=kwargs.get('width', self.config.entry_width),
+            height=kwargs.get('height', self.config.entry_height),
+            font=kwargs.get('font', self.config.entry_font),
+            text_color=kwargs.get('text_color', self.config.entry_text_color),
+            fg_color=kwargs.get('fg_color', self.config.entry_fg_color),
+            border_color=kwargs.get('border_color', self.config.entry_border_color),
+            **{k: v for k, v in kwargs.items() if k not in ['width', 'height', 'font', 'text_color', 'fg_color', 'border_color']}
+        )
+    
+    def create_frame(self, parent, **kwargs):
+        return ctk.CTkFrame(
+            parent,
+            fg_color=kwargs.get('fg_color', self.config.frame_fg_color),
+            **{k: v for k, v in kwargs.items() if k not in ['fg_color']}  # ← Add this
+        )
+        
+    def create_progress_bar(self, parent, **kwargs):
+        return ctk.CTkProgressBar(
+            parent,
+            width=kwargs.get('width', self.config.progress_bar_width),
+            height=kwargs.get('height', self.config.progress_bar_height),
+            progress_color=kwargs.get('progress_color', self.config.progress_bar_color),
+            **{k: v for k, v in kwargs.items() if k not in ['width', 'height', 'progress_color']}
+        )
+    
+    def create_checkbox(self, parent, text="", **kwargs):
+        """Create a checkbox with consistent styling from config"""
+        return ctk.CTkCheckBox(
+            parent,
+            text=text,
+            font=kwargs.get('font', self.config.label_font),
+            text_color=kwargs.get('text_color', self.config.label_text_color),
+            fg_color=kwargs.get('fg_color', self.config.button_fg_color),
+            hover_color=kwargs.get('hover_color', self.config.button_hover_color),
+            **{k: v for k, v in kwargs.items() if k not in ['font', 'text_color', 'fg_color', 'hover_color']}
+        )
+
+
+# testing this shit
+    
+    def show(self):
+        def ui(app):
+            self.build_ui(app)
+        
+        BaseDialogRunner.run_dialog(ui, self.config)
+        return self.result
+    
+    def build_ui(self, app):
+        raise NotImplementedError

DialogsPlus/widgets/styling.py

@@ -0,0 +1,337 @@
+from DialogsPlus.widgets.base import BaseDialog, filedialog, BooleanVar, IntVar
+import time
+
+
+
+class InputDialog(BaseDialog):
+    
+    def __init__(self, prompt, default="", config=None, is_error=False):
+        super().__init__(config)
+        self.prompt = prompt
+        self.default = default
+        self.is_error = is_error
+    
+    def build_ui(self, app):
+        frame = self.create_frame(app)
+        frame.pack(pady=8)
+
+        label = self.create_label(frame, text=self.prompt)
+        label.pack() 
+
+        entry_frame = self.create_frame(app)
+        entry_frame.pack(pady=8)
+        entry = self.create_entry(entry_frame)
+        entry.insert(0, self.default)
+        entry.pack()
+        
+        def on_submit():
+            self.result['value'] = entry.get()
+            app.quit()
+        
+        app.protocol("WM_DELETE_WINDOW", app.quit)
+        app.bind('<Return>', lambda e: on_submit())
+        app.bind('<Escape>', lambda e: app.quit())
+        
+        entry.focus_set()
+        
+        button_frame = self.create_frame(app)
+        button_frame.pack(pady=10)
+        self.create_button(button_frame, text="Submit", command=on_submit).pack()
+
+
+class ManualStepDialog(BaseDialog):
+    
+    def __init__(self, message, config=None):
+        super().__init__(config)
+        self.message = message
+    
+    def build_ui(self, app):
+        def on_pass():
+            self.result["status"] = "pass"
+            app.quit()
+
+        def on_fail():
+            self.result["status"] = "fail"
+            app.quit()
+
+        app.protocol("WM_DELETE_WINDOW", app.quit)
+        app.bind('<Escape>', lambda e: app.quit())
+
+        self.create_label(app, text=self.message).pack(pady=25)
+
+        button_frame = self.create_frame(app)
+        button_frame.pack(pady=(10, self.config.spacing), expand=True)
+
+        self.create_button(
+            button_frame,
+            text="PASS",
+            command=on_pass).pack(side="left", padx=10)
+
+        self.create_button(
+            button_frame,
+            text="FAIL",
+            command=on_fail).pack(side="left", padx=10)
+
+
+class CountdownDialog(BaseDialog):
+    
+    def __init__(self, seconds, message="Please wait...", config=None):
+        super().__init__(config)
+        self.seconds = seconds
+        self.message = message
+    
+    def build_ui(self, app):
+        
+        label = self.create_label(app, text="")
+        label.place(relx=0.5, rely=0.4, anchor="center")
+
+        progress = self.create_progress_bar(app)
+        progress.place(relx=0.5, rely=0.8, anchor="center")
+        progress.set(0)
+
+        start_time = time.perf_counter()
+
+        def update():
+            elapsed = time.perf_counter() - start_time
+            remaining = self.seconds - elapsed
+
+            if remaining > 0:
+                mins, secs = divmod(int(remaining), 60)
+                label.configure(text=f"{self.message}\n{mins:02}:{secs:02}")
+                progress.set(min(elapsed / self.seconds, 1))
+                app.after(100, update)
+            else:
+                progress.set(1)
+                label.configure(text=f"{self.message}\n00:00")
+                app.quit()
+
+        update()
+
+
+class ConfirmationDialog(BaseDialog):
+    def __init__(self, message, default="Yes", config=None):
+        super().__init__(config)
+        self.message = message
+        self.default = default
+    
+    def build_ui(self, app):
+
+        def on_yes():
+            self.result["status"] = "yes"
+            app.quit()
+
+        def on_no():
+            self.result["status"] = "no"
+            app.quit()
+
+        def on_cancel():
+            self.result["status"] = "cancel"
+            app.quit()
+
+        app.protocol("WM_DELETE_WINDOW", app.quit)
+        app.bind('<Escape>', lambda e: app.quit())
+
+        self.create_label(app, text=self.message).pack(pady=25)
+
+        button_frame = self.create_frame(app)
+        button_frame.pack(pady=(10, self.config.spacing), expand=True)
+
+        self.create_button(
+            button_frame,
+            text="Yes",
+            command=on_yes).pack(side="left", padx=5)
+
+        self.create_button(
+            button_frame,
+            text="No",
+            command=on_no).pack(side="left", padx=5)
+
+        self.create_button(
+            button_frame,
+            text="Cancel",
+            command=on_cancel).pack(side="left", padx=5)
+        
+        
+
+
+class MultiValueInputDialog(BaseDialog):
+    def __init__(self, fields, defaults=None, config=None):
+        super().__init__(config)
+
+        # Normalize string input to list
+        self.fields = fields if isinstance(fields, list) else [fields]
+        self.defaults = defaults or {}
+        self.entries = {}
+
+    def build_ui(self, app):
+        def on_submit():
+            self.result = {field: self.entries[field].get() for field in self.fields}
+            self.result["status"] = "pass"
+            app.quit()
+
+        def on_cancel():
+            self.result["status"] = "fail"
+            app.quit()
+
+        app.protocol("WM_DELETE_WINDOW", on_cancel)
+        app.bind('<Escape>', lambda e: on_cancel())
+        app.bind('<Return>', lambda e: on_submit())
+
+        main_frame = self.create_frame(app)
+        main_frame.pack(fill="both", expand=True, padx=10, pady=10)
+
+        title = self.create_label(main_frame, text="Enter values")
+        title.pack(pady=25)
+
+        fields_frame = self.create_frame(main_frame)
+        fields_frame.pack(fill="both", expand=True)
+
+        for field in self.fields:
+            row_frame = self.create_frame(fields_frame)
+            row_frame.pack(fill="x", pady=5)
+
+            label = self.create_label(row_frame, text=field)
+            label.pack(side="left", padx=(0, 10))
+
+            entry = self.create_entry(row_frame)
+            entry.insert(0, self.defaults.get(field, ""))
+            entry.pack(side="left", fill="x", expand=True)
+
+            self.entries[field] = entry
+
+        # Buttons
+        button_frame = self.create_frame(app)
+        button_frame.place(relx=0.5, rely=0.8, anchor="center")
+
+        submit_btn = self.create_button(button_frame, text="Submit", command=on_submit)
+        submit_btn.pack(side="left", padx=5)
+
+        cancel_btn = self.create_button(button_frame, text="Cancel", command=on_cancel)
+        cancel_btn.pack(side="left", padx=5)
+
+
+
+
+
+class FileDialog(BaseDialog):
+    def __init__(self, message="", filetypes=None, multiple=False, config=None):
+        super().__init__(config)
+        self.title = self.config.title
+        self.message = message
+        self.filetypes = filetypes or [("All files", "*.*")]
+        self.multiple = multiple
+    
+    def build_ui(self, app):
+        # app.withdraw()  # Hide the main window
+        
+        def on_browse():
+            if self.multiple:
+                files = filedialog.askopenfilenames(title=self.title, filetypes=self.filetypes)
+                self.result['files'] = list(files) if files else None
+                
+            else:
+                file = filedialog.askopenfilename(title=self.title, filetypes=self.filetypes)
+                self.result['file'] = file if file else None
+        
+            app.quit()
+
+        app.protocol("WM_DELETE_WINDOW", app.quit)
+        app.bind('<Escape>', lambda e: app.quit())
+
+        self.create_label(app, text=self.message).pack(pady=25)
+
+        button_frame = self.create_frame(app)
+        button_frame.pack(pady=(10, self.config.spacing), expand=True)
+
+
+        self.create_button(
+            button_frame,
+            text="Browse",
+            command=on_browse).pack(side="bottom", padx=10)
+
+
+class FolderDialog(BaseDialog):
+    def __init__(self, message, config=None):
+        super().__init__(config)
+        self.title = self.config.title
+        self.message = message
+    
+    def build_ui(self, app):
+        #app.withdraw()  # Hide the main window
+        
+        def on_browser_folder():
+            folder = filedialog.askdirectory(title=self.title)
+            self.result['folder'] = folder if folder else None
+            app.quit()
+        
+        app.protocol("WM_DELETE_WINDOW", app.quit)
+        app.bind('<Escape>', lambda e: app.quit())
+
+        self.create_label(app, text=self.message).pack(pady=25)
+
+        button_frame = self.create_frame(app)
+        button_frame.pack(pady=(10, self.config.spacing), expand=True)
+
+
+        self.create_button(
+            button_frame,
+            text="Browse",
+            command=on_browser_folder).pack(side="bottom", padx=10)
+        
+
+class CheckboxConfirmationDialog(BaseDialog):
+    def __init__(self, message, checkbox_text="I agree", config=None):
+        super().__init__(config)
+        self.message = message
+        self.checkbox_text = checkbox_text
+    
+    def build_ui(self, app):
+        checkbox_var = BooleanVar(value=False)
+        
+        def on_submit():
+            self.result['confirmed'] = checkbox_var.get()
+            app.quit()
+        
+        app.protocol("WM_DELETE_WINDOW", app.quit)
+        app.bind('<Escape>', lambda e: app.quit())
+        app.bind('<Return>', lambda e: on_submit())
+        
+        self.create_label(app, text=self.message).pack(pady=10)
+        
+        self.create_checkbox(app, text=self.checkbox_text, variable=checkbox_var).pack(pady=10)
+        
+        self.create_button(app, text="Submit", command=on_submit).pack(pady=10)
+
+
+class MultiCheckboxDialog(BaseDialog):
+    def __init__(self, message, options, defaults=None, config=None):
+        super().__init__(config)
+        self.message = message
+        self.options = options if isinstance(options, list) else options.split('|')
+        self.defaults = defaults or []
+        self.checkbox_vars = {}
+    
+    def build_ui(self, app):
+        def on_submit():
+            self.result = {option: var.get() for option, var in self.checkbox_vars.items()}
+            app.quit()
+        
+        app.protocol("WM_DELETE_WINDOW", app.quit)
+        app.bind('<Escape>', lambda e: app.quit())
+        app.bind('<Return>', lambda e: on_submit())
+        
+        self.create_label(app, text=self.message).pack(pady=20)
+        
+        # Checkboxes frame
+        checkbox_frame = self.create_frame(app)
+        checkbox_frame.pack(pady=10, padx=20, fill="both", expand=True)
+        
+        for option in self.options:
+            var = BooleanVar(value=(option in self.defaults))
+            self.checkbox_vars[option] = var
+            
+            self.create_checkbox(checkbox_frame, text=option, variable=var).pack(
+                anchor="w", pady=5, padx=10
+            )
+        
+        self.create_button(app, text="Submit", command=on_submit).pack(pady=20)

DialogsPlus/widgets/wrappers.py

@@ -0,0 +1,118 @@
+from DialogsPlus.widgets.styling import ( InputDialog, 
+                                          ManualStepDialog, 
+                                          CountdownDialog, 
+                                          ConfirmationDialog, 
+                                          MultiValueInputDialog,
+                                          FileDialog,
+                                          FolderDialog,
+                                          CheckboxConfirmationDialog,
+                                          MultiCheckboxDialog)
+from robot.api import logger
+from robot.errors import ExecutionFailed
+
+
+class GetValueFromUserDialog:
+    @staticmethod
+    def show(prompt="Enter value:", default="", config=None):
+        dialog = InputDialog(prompt, default, config)
+        return dialog.show().get('value')
+    
+
+class ExecuteManualStepDialog:
+    @staticmethod
+    def show(message="Please perform the step and confirm.", config=None):
+        logger.info(message)
+        
+        dialog = ManualStepDialog(message, config)
+        result = dialog.show()
+
+        if result.get("status") == "pass":
+            return
+        else:
+            failure_dialog = InputDialog("Test Failed - Reason:", "", config, is_error=True)
+            reason = failure_dialog.show().get('value', 'No reason provided')
+            logger.error(f"{message} | Reason: {reason}")
+            raise ExecutionFailed(reason)
+
+    @staticmethod
+    def run_steps(steps, config=None):
+        if isinstance(steps, str):
+            ExecuteManualStepDialog.show(steps, config)
+        elif isinstance(steps, list):
+            for step in steps:
+                ExecuteManualStepDialog.show(step, config)
+        else:
+            raise ExecutionFailed("Invalid input: must be a string or a list of strings.")
+        
+
+class CountdownDialogRunner:
+    @staticmethod
+    def show(seconds=10, message="Please wait...", config=None):
+        logger.info(f"Starting countdown for {seconds} seconds...")
+        dialog = CountdownDialog(seconds, message, config)
+        dialog.show()
+
+
+class GetConfirmationFromUser:
+    @staticmethod
+    def show(message="Are you sure?", default="Yes", config=None):
+        logger.info(message)
+        dialog = ConfirmationDialog(message, default, config)
+        dialog.config.width = 450
+        result = dialog.show().get("status")
+        
+        if result == "yes":
+            return True
+        elif result == "no":
+            return False
+        else:  # cancel
+            return None
+        
+
+class MultiValueInput:
+    @staticmethod
+    def show(fields, defaults=None, config=None):
+        logger.info(f"Showing input dialog for: {fields}")
+        dialog = MultiValueInputDialog(fields, defaults=defaults, config=config)
+        result = dialog.show()
+        if result.get("status") == "pass":
+            return result
+        else:
+            return None
+
+    @staticmethod
+    def run_multival(fields, config=None, defaults=None):
+        return MultiValueInput.show(fields, defaults=defaults, config=config)
+
+class ChooseFromFileDialog:
+    @staticmethod
+    def show(message="", filetypes=None, multiple=False, config=None):
+        logger.info(f"Opening file picker: {message}")
+        dialog = FileDialog(message, filetypes, multiple, config)
+        result = dialog.show()
+        return result.get('files' if multiple else 'file')
+
+
+class ChooseFolderDialog:
+    @staticmethod
+    def show(message, config=None):
+        logger.info(f"Opening folder picker: {message}")
+        dialog = FolderDialog(message, config)
+        return dialog.show().get('folder')
+    
+
+class ConfirmWithCheckbox:
+    @staticmethod
+    def show(message, checkbox_text="I agree", config=None):
+        logger.info(f"Showing checkbox confirmation: {message}")
+        dialog = CheckboxConfirmationDialog(message, checkbox_text, config)
+        result = dialog.show()
+        return result.get('confirmed', False)
+    
+
+class SelectOptionsWithCheckboxes:
+    @staticmethod
+    def show(message, options, defaults=None, config=None):
+        logger.info(f"Showing multi-checkbox dialog: {message}")
+        dialog = MultiCheckboxDialog(message, options, defaults, config)
+        return dialog.show()

robotframework_dialogsplus-0.1.0.dist-info/METADATA

@@ -0,0 +1,37 @@
+Metadata-Version: 2.4
+Name: robotframework-dialogsplus
+Version: 0.1.0
+Summary: A drop-in enhancement for Robot Framework's Dialogs library with modern UI and extended user interaction keywords.
+Author-email: Alpha-Centauri-00 <Alpha@Centauri.c0m>
+License-Expression: MIT
+Requires-Python: >=3.10
+Requires-Dist: customtkinter>=5.2.2
+Requires-Dist: pyyaml>=6.0.3
+Requires-Dist: robotframework>=7.3.2
+Description-Content-Type: text/markdown
+
+# DialogsPlus
+A drop-in enhancement for Robot Framework's Dialogs library with modern UI and extended user interaction keywords.
+
+### ⚠️ Known Limitations
+
+- Not supported in headless environments such as CI/CD pipelines (e.g., Jenkins, GitHub Actions)
+
+
+**DialogsPlus** is a user-friendly and fully customizable dialog library for [Robot Framework](https://robotframework.org/), built on top of [`customtkinter`](https://github.com/TomSchimansky/CustomTkinter). It extends the built-in dialog functionality with rich GUI dialogs that are **stylish**, **modern**, and **configurable** via a simple `config.yaml` file.
+
+---
+
+## ✨ Features
+
+- Easy-to-use dialogs for user interaction during test runs
+- Full GUI-based interface using `customtkinter`
+- Customizable look and feel (colors, fonts, sizes, etc.) via `config.yaml`
+- Drop-in replacement for standard Robot Framework dialogs
+- Supports dynamic sizing based on input fields or options
+
+---
+
+
+
+Pull requests are welcome! More info coming soon.

robotframework_dialogsplus-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+DialogsPlus/__init__.py,sha256=bj2en4W8oOadu0BgP-BMmhOB1woGUFfNYRyQIffTCWI,102
+DialogsPlus/dialogsplus.py,sha256=EEZpMYvu8Evu3V_Xy-0hNl5UsaCMa4VWJUycm59wZG0,3630
+DialogsPlus/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+DialogsPlus/utils/config.py,sha256=aPoNgC5RPOtp6yEZiNQkj-qhyLTo391eEscqjL2w9_M,2864
+DialogsPlus/widgets/base.py,sha256=lyTnRtnE1aI0rCrqG6a17kIjcFNcacTZr3rmQ0zmCm0,5929
+DialogsPlus/widgets/styling.py,sha256=LL-O-gPUw3I_QIqn05BK02SEE4qnVt9beNV_nQjmMXk,10981
+DialogsPlus/widgets/wrappers.py,sha256=oVa-ScnDNr8IdGv2aR_HKflL5DhCeqVlO-Ix5C5snS8,4352
+DialogsPlus/widgets/assets/robot.ico,sha256=Ikez3We-xWB3jvB7WMXB5mpgxUx57ebZbR1hcmBkoZk,7744
+robotframework_dialogsplus-0.1.0.dist-info/METADATA,sha256=ZfSv2NzmNoYgbrl71LrEOKpsDSlEBn9uQi5yE6F-mlA,1443
+robotframework_dialogsplus-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+robotframework_dialogsplus-0.1.0.dist-info/RECORD,,

robotframework_dialogsplus-0.1.0.dist-info/WHEEL

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