jabs-mimir 0.5.3

A reusable tkinter/ttkbootstrap UI framework

Jabs Mimir

Jabs Mimir is a lightweight, extensible UI micro-framework built on top of tkinter and ttkbootstrap, designed for rapid internal tool development and structured form workflows.

It provides:

• Reusable UI primitives with validation and tooltips
• Support for block-based form components with dynamic variable binding
• Integration with custom validation logic (via resolver, file loader, or direct function)
• Modular architecture suitable for internal tooling and small boilerplate projects

---

Installation

pip install jabs-mimir

---

Quick Start

from jabs_mimir import Mimir, DataBlockWrapper, UtilityModule
import tkinter as tk
import ttkbootstrap as tb

class App(tb.Window):
    def __init__(self):
        super().__init__(title="Mimir Demo")
        self.ui = Mimir(self)

        # Option 1: Inline validator resolver (string-based)
        self.ui.setValidatorResolver(lambda name: {
            "not_empty": lambda val: bool(str(val).strip())
        }.get(name))

        # Option 2 (alternative): load from file
        # self.ui.setValidatorFile("include/validator.py")

        self.ui.switchView(self.mainView)

    def mainView(self, ui, *args):
        frame = tb.Frame(self)
        fields = [
            {"type": "heading", "label": "Basic Info"},
            {"label": "Name", "key": "name", "variable": tk.StringVar(), "validation": "not_empty"},
            {"label": "Age", "key": "age", "variable": tk.IntVar()}
        ]

        meta = UtilityModule.buildBlockMeta(fields)
        block = DataBlockWrapper(meta)

        ui.renderFields(frame, fields)
        ui.addNextButton(frame, row=len(fields)+1, viewFunc=self.mainView)

        return frame

if __name__ == "__main__":
    app = App()
    app.mainloop()

---

Validation

Jabs Mimir supports both automatic and manual validation, triggered on field focus-out and verified again when clicking "Next".

You can define validation in two ways:

1. String-based validation (via file or resolver)

Define a validator in a file:

# include/validator.py
def not_empty(value):
    return bool(str(value).strip())

Load it:

self.ui.setValidatorFile("include/validator.py")

Use string key in field:

{"label": "Name", "variable": tk.StringVar(), "validation": "not_empty"}

2. Direct function reference

from include.validator import not_empty

fields = [
    {"label": "Name", "variable": tk.StringVar(), "validation": not_empty}
]

Both methods are fully supported and interchangeable.

Mimir automatically:

• Binds validation on focus-out
• Stores all validators internally
• Re-validates all fields when clicking "Next"
• Blocks navigation if any invalid inputs remain
• Highlights invalid fields with red styling

Works even for readonly fields (like file upload paths), which normally can't be focused.

---

Buttons & Navigation

Mimir provides helpers for both view transitions and general-purpose action buttons.

addNextButton(...)

Use this when you want a button that:

• Runs validation on all fields
• Automatically switches to a new view
• Looks like a "next step" button

self.ui.addNextButton(parent, row=5, viewFunc=initERPInput, label="Next")

addButton(...)

Use this when you want full control over what happens on click.

• Can be used with or without validation (validate=True or False)
• Perfect for "Save", "Preview", or conditional logic buttons

self.ui.addButton(parent, row=6, command=self.doSomething, label="Save", validate=True)

If you just want to go to the next frame with validation, use addNextButton. If you want to run custom logic (e.g. saving data, previewing content, or optionally switching views), use addButton instead.

---

Working with Blocks

Mimir makes it easy to group inputs into reusable, structured blocks of fields (also called Data Blocks). These blocks:

• Are defined using a list of field dictionaries
• Can be rendered vertically or horizontally
• Are assigned metadata for identification (store_id, custom_label, etc.)
• Can be validated, modified, and repeated dynamically
• Wrap all data in a DataBlockWrapper

Creating a Field Block

fields = [
    {"type": "heading", "label": "Store 1"},
    {"label": "Cash", "key": "cash", "variable": tk.DoubleVar()},
    {"label": "Card", "key": "card", "variable": tk.DoubleVar()}
]

meta = UtilityModule.buildBlockMeta(fields, store_id=1)
block = DataBlockWrapper(meta)

Rendering a Block in the UI

self.blocks = []

self.ui.renderBlockUI(
    container=frame,
    fields=fields,
    blockList=self.blocks,
    layout="vertical",
    label="Store 1",
    meta={"store_id": 1}
)

This will create a labeled block frame (with remove button), populate it with your fields, and store the block object in self.blocks.

Accessing Block Data

for block in self.blocks:
    print("Cash:", block.get("cash").get())
    print("Card:", block.get("card").get())

You can also loop through and validate them with:

valid_blocks = [b for b in self.blocks if UtilityModule.isBlockValid(b)]

Repeating Dynamic Blocks

for i in range(5):
    self.ui.renderBlockUI(
        container=frame,
        fields=fields,
        blockList=self.blocks,
        label=f"Store {i+1}",
        meta={"store_id": i+1}
    )

---

InfoBox (Information Panels)

Mimir allows you to create information panels ("info boxes") easily, styled consistently with your forms.
You can choose to render them with or without a border.

Basic Example

self.ui.addInfoBox(
    parent=frame,
    row=0,
    text="This is important information for the user to know.",
    label="Important Info",    # Optional title
    border=True                # Optional, default is True
)

This will create a framed info box (LabelFrame) at the top of your form.

---

Borderless InfoBox

If you prefer a clean info panel without a frame or border:

self.ui.addInfoBox(
    parent=frame,
    row=0,
    text="This text will be shown without a surrounding frame.",
    border=False
)

When border=False, the label title is ignored and only the text is shown inside a standard frame.

---

How It Works

Internally, the InfoBox:

• Expands horizontally to match the parent container
• Uses the same font and style as the rest of your form
• Supports text wrapping (default 500px)
• Optionally resizes dynamically if you bind a <Configure> event
• Fits naturally into both block-style layouts and simple forms

---

Creating Custom Field Types

Mimir supports custom, reusable field types through the registerFieldType() method.
This makes it easy to extend the UI with your own specialized inputs without modifying the core library.

You can register any type of widget — like a DatePicker, a custom file selector, a styled text input, etc.

---

How to Create a Custom Field Type

1. Define a Renderer Function
   A renderer is a function that receives the parent container, row number, and the field definition, and creates the widget.

2. Register the Renderer
   Tell Mimir about your new field type with registerFieldType(name, renderer).

3. Use Your New Field Type
   In your field definitions, specify your custom type via {"type": "your_type", ...}.

---

Example: Custom File Upload Field

Step 1: Create a Renderer

def fileUploadRenderer(parent, row, field):
    import tkinter as tk
    import ttkbootstrap as tb

    # Create a container frame for the file input + button
    frame = tb.Frame(parent)
    frame.grid(row=row, column=0, columnspan=2, pady=5, sticky="ew")

    # Entry to display selected file
    entry = tb.Entry(frame, textvariable=field["variable"], width=40)
    entry.pack(side="left", padx=(0, 5), fill="x", expand=True)

    # Browse button
    def browse():
        from tkinter import filedialog
        filename = filedialog.askopenfilename()
        if filename:
            field["variable"].set(filename)

    button = tb.Button(frame, text="Browse", command=browse)
    button.pack(side="right")

    return entry  # Returning the entry allows automatic validation binding

Step 2: Register It

self.ui.registerFieldType("fileupload", fileUploadRenderer)

Step 3: Use It

fields = [
    {"label": "Select File", "key": "filePath", "variable": tk.StringVar(), "type": "fileupload"}
]

Important Notes

• Your custom renderer must return the widget if you want automatic validation (focus-out validation) to work.
• Your renderer can return None if no validation is needed.
• Mimir will automatically attach validation if the widget supports .get().

Final Tip

if your custom widget needs extra options pass them through the options key.

fields = [
    {"label": "Upload File", "key": "file", "variable": tk.StringVar(), "type": "fileupload", "options": {"filetypes": [("PDF files", "*.pdf")]}}
]

And in you renderer

options = field.get("options", {})
filetypes = options.get("filetypes", [("All files", "*.*")])

---

Components

Mimir

Manages UI views, tooltips, validation, field rendering, and form logic.
Supports reusable custom field types via registerFieldType().

DataBlockWrapper

A wrapper for block-level form metadata and values.
Supports dot-access and .get()/.set() calls.

UtilityModule

Helper methods for building field metadata, extracting values, validating blocks, and block meta handling.

---

License

MIT License © 2025 William Lydahl