Coder Legion - Recent posts tagged library

Migrating a Real TypeScript OSS Library from tsup to tsdown 🔧

Fri, 09 Oct 2026 18:00:41 +0000

The config migration was small. Preserving the package contract was the interesting part.

Hoi hoi! 👋

I'm @nyaomaru, a frontend engineer who enjoyed looking for fungus this season. 😸🍄

Recently, I migrated its build setup from tsup to tsdown.

At first, I expected this to be a very small task.

Just remove tsup.
Just install tsdown.
Just change the config.
Run the build.
Done! 🎉

And honestly...

The config migration was small.

But there was one interesting problem.

The first tsdown build succeeded while silently changing files that were already part of the package's public contract.

So this article isn't really an introduction to tsdown.

Instead, I want to show what happened when I migrated a real published TypeScript library from tsup to tsdown, what actually changed, and how I verified that consumers would still receive the same package.

Let's take a look! 👀

🤔 Why Migrate a Package That Already Builds Correctly?

is-kit is a zero-dependency TypeScript library for runtime type guards.

Its build setup was already pretty boring.

And boring build systems are good. 😸

The package had:

one entry point
ESM and CJS outputs
bundled declaration files
explicit package.json exports
a declaration banner
a packed-package smoke test

Before the migration, it used

Environment	Value
Package	`is-kit@1.14.2`
Bundler	`tsup@8.5.1`
Entry	`src/index.ts`
Output	`ESM + CJS + bundled declarations`
Target	`esnext`

I wasn't trying to solve a broken build.

The motivation was mostly maintenance.

tsdown is built around Rolldown, has an active ecosystem, and is explicitly designed as a migration path for projects currently using tsup.

So the question wasn't

Can tsdown build this library?

It was

Can I move the build setup to tsdown without changing what existing consumers receive?

That's a much more useful question for a published package.

📦 The Package Contract I Needed to Preserve

For an application, changing an output filename may not matter much.

For a library, it can be a breaking change.

is-kit already exposes files through explicit package exports.

The important paths were effectively

{
  "exports": {
    ".": {
      "types": "./dist/index.d.ts",
      "import": "./dist/index.mjs",
      "require": "./dist/index.js"
    }
  }
}

So I wanted the migration to preserve

dist/index.mjs
dist/index.js
dist/index.d.ts

along with the existing ESM/CJS runtime behavior, declaration compatibility, export set, and declaration banner.

In other words

The source code was not the contract here. The packed npm package was.

That distinction became important very quickly.

🛠️ The Migration Looked Almost Trivial

I replaced tsup with tsdown and replaced

tsup.config.ts

with

tsdown.config.mts

I intentionally used .mts.

The package itself is not "type": "module", and using an ESM-specific config extension avoids having Node reinterpret the config file and emit related warnings.

Most of the important options mapped almost directly.

import { defineConfig } from "tsdown";

export default defineConfig({
  entry: ["src/index.ts"],
  format: ["esm", "cjs"],
  dts: true,
  clean: true,
  outDir: "dist",
  target: "esnext",
  banner: {
    dts: dtsBanner,
  },
});

The declaration banner also stayed dts-only with banner: { dts: dtsBanner }.

So far, everything looked easy.

Then I ran the build.

It passed.

And the package contract was wrong. 🙀

💥 The First Build Succeeded and Changed My Filenames

This was the interesting part.

Before the migration, the important generated files looked like this:

Build	Main generated files
`tsup`	`index.mjs`, `index.js`, `index.d.ts`
default `tsdown` migration	`index.mjs`, `index.cjs`, `index.d.mts`, `index.d.cts`

The tsdown build completed successfully with exit code 0.

But my existing package.json still expected

require → ./dist/index.js
types   → ./dist/index.d.ts

Those files no longer matched the generated output.

If I had stopped at

pnpm build

and published the package.

CJS consumers and TypeScript resolution could have been broken.

This was the most important lesson from the migration

Build success ≠ package contract preserved.

A bundler only knows whether it successfully produced its output.

It doesn't automatically mean that output still matches every promise your already-published package makes.

🔧 Fixing the Public Contract with `outExtensions`

The tsdown migration guide explicitly calls out the rename from outExtension to outExtensions.

For is-kit, I used it to preserve the existing filenames

outExtensions: ({ format }) => ({
  dts: format === 'cjs' ? '.d.ts' : '.d.mts',
  js: format === 'cjs' ? '.js' : '.mjs',
}),

Now the relevant output became

dist/index.mjs
dist/index.js
dist/index.d.mts
dist/index.d.ts

and the existing exports continued to resolve correctly.

I don't really consider the original output behavior a tsdown bug.

tsdown chooses extensions based on the package type and output format to avoid ambiguous module interpretation.

That's reasonable.

But for an existing package, reasonable new defaults are still changes.

If consumers already depend on your filenames, those filenames are part of your compatibility surface.

🧪 Verifying the Published Package with a Smoke Test

This is where an existing packed-package smoke test in is-kit helped a lot.

I already had a pnpm test:package command that builds the package, runs npm pack, installs the generated tarball into a temporary project, and verifies it from a real consumer's perspective.

Instead of testing this

src/index.ts

it tests this

is-kit-1.14.2.tgz
        ↓
temporary consumer
        ↓
npm install

A library can work perfectly inside its own repository while still publishing a broken package, so this smoke test exercises the artifact that users would actually install.

After the migration, I expanded the test to verify more of the package contract 👇

Contract	Result
`exports["."].import` → `./dist/index.mjs`	✅ pass
`exports["."].require` → `./dist/index.js`	✅ pass
`exports["."].types` → `./dist/index.d.ts`	✅ pass
Runtime dependencies	✅ 0
ESM exports	✅ same 83 exports
CJS exports	✅ same 83 exports
Declaration banner	✅ preserved
ESM runtime import	✅ pass
CJS runtime require	✅ pass
Packed TypeScript consumer	✅ pass

I also installed the packed package into temporary consumer projects using TypeScript v5.7 through v7.0.

All of them successfully resolved and consumed the generated declarations.

This isn't testing whether each TypeScript version can generate declarations through tsdown. It's testing the artifact my users actually install.

So if a future build change accidentally alters an extension, export path, declaration file, or runtime behavior, the smoke test should catch it before publishing.

For a library migration like this, that is much more meaningful than simply asserting "build exited successfully".

📏 The Output Actually Got Bigger

I was also curious about artifact size.

This produced a result I didn't expect.

Metric	`tsup`	`tsdown`	Difference
JS + dts total	116,503 B	144,007 B	+23.6%
ESM JavaScript	15,787 B	29,410 B	+86.3%
CJS JavaScript	19,318 B	31,155 B	+61.3%
dts, one format	40,699 B	41,721 B	+2.5%
`npm pack` tarball	37,226 B	42,366 B	+13.8%

In this configuration, the tsdown output retained more comments and region markers than the previous tsup output.

So the raw JavaScript became noticeably larger.

Compression reduced the difference in the actual npm tarball, but didn't remove it.

For is-kit, this isn't particularly concerning.

It is a small zero-dependency utility library, and we're talking about a few kilobytes in the final tarball.

But it was still a useful reminder

A faster or newer bundler does not automatically mean a smaller artifact.

If package size is a strict constraint for your library, I would compare the generated files and decide on your minification strategy before migrating.

⏱️ What About Build Performance?

I also measured wall-clock build time.

The old tsup build

1.50 s

The new tsdown build across three runs

1.22 s
1.17 s
1.18 s

Looking only at those numbers, it would be very tempting to say

tsdown made the build faster! 🚀

But I don't think this benchmark supports that conclusion.

I only have one measured tsup run in this comparison.

Also, this is a tiny single-entry library where declaration generation represents a large part of the build.

The bundlers' own timing output was roughly

tsup
JavaScript: ~22 ms
dts:        ~707 ms

tsdown
complete:   ~717–755 ms

The wall-clock result was better, but with only one tsup sample and declaration generation dominating this tiny library, I don't think this is enough evidence to claim a meaningful performance improvement.

But no, I'm not migrating because I saved around 300 ms.

🐱 Was the Migration Actually Small?

For is-kit, yes.

There were no source-code changes.

The migration was basically limited to

dependency
config
task documentation
package smoke assertions

The important options were almost one-to-one.

But I think it's important to explain why it stayed small.

is-kit has

one entry
zero runtime dependencies
no bundler plugins
no CSS pipeline
no complicated code splitting

and, most importantly, it already had a way to test the packed package as a consumer.

The migration becomes more interesting if your package relies on custom plugins, unusual entries, CSS processing, exact source maps, generated exports, strict byte-size limits, or older Node build environments.

There is also a build-environment requirement worth checking.

For the version tested here

tsdown 0.23.0
Rolldown 1.2.8

the relevant Node engine requirement is

^22.18.0 || ^24.11.0 || >=26.0.0

My CI uses

Node 22.22.0

so that was fine.

But if contributors still build your library with Node v20 or an older Node v22 version, this is something you need to solve before migrating.

That doesn't necessarily mean your library consumers must use Node v22.

It's a build-tool requirement.

Still, contributor and CI environments are part of the migration cost too. 😿

🎯 So, Was Moving from tsup to tsdown Worth It?

For is-kit, I think yes.

But not because of performance.

The migration preserved the package contract across ESM, CJS, declarations, exports, and the packed-package consumer tests.

The configuration change was small and reviewable.

My existing Node environment satisfies the new build requirement.

And the build setup is now aligned with the actively evolving Rolldown ecosystem.

The cost was also real

artifact size increased
Node build requirements increased
output extensions needed explicit configuration

So I wouldn't describe this as

Everyone using tsup should migrate immediately because tsdown is faster!

That's not what this experiment showed.

For me, the better conclusion is

If your project already meets the Node requirements and you want to move your build setup toward the Rolldown ecosystem, migrating a small library from tsup to tsdown can be a very reasonable change.

But verify the package you publish.

Not only the source.
Not only the config.
And definitely not only the green build message. 😸

Because the most interesting bug in this migration happened when the build said everything was fine.

If you'd like to see the package from this article in a real project, is-kit is open source.

It's a lightweight, zero-dependency TypeScript type guard library focused on runtime validation and safe narrowing.

If it looks useful for your project, I'd be happy if you gave it a try and a ⭐ on GitHub is always appreciated.

https://github.com/nyaomaru/is-kit

Issues and PRs are welcome too. 😸

Handling Exceptions Like a Pro in Java

Mon, 21 Jul 2025 19:21:30 +0000

Handling Exceptions Like a Pro in Java: Stop Using catch-All Blocks

If you only handle Exceptions in Java with just generic try-catch then I appeal you to stop and try these below tips instead, you'll thank me later :)

Let’s be honest — most of us start out doing the lazy thing:

try {
    // risky code
} catch (Exception e) {
    e.printStackTrace();
}

Looks safe. But what you've actually written is the software equivalent of sweeping all the dirt under the rug. No clue what went wrong. No proper recovery. Just vibes. Which I bet is a menace to mankind.

Let’s fix that. Let's learn how real Java pros handle exceptions — with intention, clarity, and sometimes, a touch of functional programming.

The Problem with Catch-Alls

Catching Exception or worse, Throwable, is like saying “I don’t know what might break, so I’ll just catch everything.” But that makes your app unpredictable and hard to debug.

catch (Exception e) {
    // What are you even catching here? FileNotFound? NullPointer?
    // Did you miss an InterruptedException that should be re-thrown?
}

You're hiding the bugs that should scream in your face during development.

So rule no. 1: Be specific. Catch only what you’re ready to handle.

Catch the Exact Thing You’re Solving

Let's say you're reading a file:

try {
    Files.readAllLines(Paths.get("data.txt"));
} catch (IOException e) {
    System.err.println("Could not read the file: " + e.getMessage());
}

Much better! Now your intention is clear, and you're handling something specific.

Bonus: This also helps you avoid accidentally swallowing critical runtime exceptions like OutOfMemoryError or InterruptedException — things that you should not handle casually.

Move to Functional-Style Exception Handling

Functional programming has been slowly sipping tea and watching us drown in imperative chaos. But now it’s time to borrow some of its elegance.

Enter libraries like Vavr.

With Vavr, you wrap potentially failing logic into a Try, and then compose your actions in a clear, fluent way which is more readable and soothing to eyes

Example :

import io.vavr.control.Try;

Try<String> content = Try.of(() -> new String(Files.readAllBytes(Paths.get("data.txt"))))
    .onFailure(e -> System.err.println("Something went wrong: " + e.getMessage()))
    .map(String::toUpperCase);

content.forEach(System.out::println);

Look at that! No try-catch noise, just pure, functional clarity. You’ve isolated the risky part and handled failure explicitly, without polluting your logic.

You can even chain retries, fallbacks, and defaults like a boss:

String result = Try.of(() -> riskyCall())
    .recover(throwable -> "default")
    .get();

This is real control over flow, not just catching and logging.

Checked vs Unchecked Exceptions — Handle Like You Mean It

Java makes this distinction. Checked exceptions (like IOException, SQLException) force you to handle or declare them. Unchecked exceptions (like NullPointerException, IllegalArgumentException) are on you to prevent.

Here’s the mindset shift:

Checked: These are expected problems (e.g., file not found, DB connection fails). Handle or bubble up with context.
Unchecked: These are code smells and should be avoided upfront via validation and logic.

Don’t convert checked exceptions into unchecked ones just because it's easier. That’s like turning off the fire alarm because it’s loud.

♂️ Clean Exception Strategy

Here’s what pros usually follow:

Fail fast. Don’t catch what you can’t handle meaningfully.
Wrap with context. If rethrowing, always add context.
Use custom exceptions to model your domain (e.g., UserNotFoundException).
Don’t log and throw. Do one — logging is for terminal exceptions.
Don’t just suppress. Silent catch blocks are crime scenes.

️ Bonus Tools That Help

Lombok’s @SneakyThrows: Can be useful, but also dangerous — it hides checked exceptions.
Vavr’s Try, Either, Option: Bring Scala-style control flow to Java, and let you reason about success/failure better.
ExceptionUtils from Apache Commons: Helps in deep exception analysis.

Final thoughts

If you're still throwing catch-all blocks and logging stack traces like confetti, it’s time to upgrade. Java gives you the tools to be precise, and functional programming gives you the grace.

Your goal should not be to handle exceptions. It should be to own them.

Make your exception handling tell a story — one that debuggers, teammates, and even future-you will appreciate.

Stop catching Exceptions, start catching intent.

Clean Async State Management with Pinia Colada

Sat, 05 Jul 2025 08:33:04 +0000

Managing async state—think loading spinners, error handling, stale data—is notoriously messy. If you’ve wrestled with nested subscriptions or redundant fetch logic in Vue+Pinia apps, Pinia Colada might be the game-changer you need.

What Is Pinia Colada?

Pinia Colada is a powerful data-fetching layer built on top of Pinia. It eliminates boilerplate by providing:

Automatic caching and deduplication
Smart query invalidation
Declarative API for queries (data fetches) and mutations
Support for optimistic updates, SSR, and tree-shaken size of \~2 KB

Quick Start

npm install pinia @pinia/colada

Then in your Vue app setup:

import { createPinia } from 'pinia'
import { PiniaColada } from '@pinia/colada'

app.use(createPinia())
app.use(PiniaColada, {/* optional plugins */})

Now you’re ready to use useQuery and useMutation everywhere.

Example: Querying Data

Instead of manual loading flags, error state, and fetch logic:

const { data, error, isPending, isLoading, refresh } = useQuery({
  key: ['users'],
  query: fetchUsers,
})

Then in the template, you can declaratively handle the three states:

isPending — first fetch
isLoading — refreshes
error — if broken
data — once resolved

Mutations & Invalidation

const { mutate: addComment, isLoading } = useMutation({
  mutation: postComment,
  onSettled: async ({ id }) => {
    await queryCache.invalidateQueries({ key: ['comments', id], exact: true })
  }
})

This lets you optimistically update and ensure fresh data before closing modal dialogs or user notifications.

Why You’ll Love It

Minimal state boilerplate: No more juggling isLoading, isError, and data manually.
Built-in caching and deduplication for better UX and efficiency.
Fully typed, tree-shakeable, zero deps (besides Pinia), and SSR-ready.
Plugins like autoRefetch and delay help avoid flickers or stale data.

Real-World Feedback

Reddit users highlight Pinia Colada's advantage for API-driven state:

“This is what Pinia stores call service methods… API calls inside sweet local store. It’s perfect to avoid multiple fetches.”

Others note:

“Pinia is for global app state. For API caching use Tanstack Query… Pinia Colada consolidates the conundrum.”

TL;DR – When to Use It

Use Pinia Colada when:

You want clean, reusable logic for API calls
You care about efficient caching and UX consistency
You prefer declarative state over imperative patterns
You work with mutable server data and want stale-data control

Want to Go Further?

Explore optimistic updates, SSR support, and GraphQL usage
Combine with Vue Router Data Loaders and modular async handling
Try plugins like auto-refetch and delay to polish UX

Pinia Colada brings a modern, well-structured approach to async state in Vue apps—cutting boilerplate, reducing bugs, and improving developer happiness. Whether it's simple CRUD or complex dialogs or pagination, it's well worth a look.

Exploring More in Tkinter

Tue, 23 Apr 2024 21:35:28 +0000

In this article, we'll delve into some of the more intricate aspects of Tkinter, exploring advanced techniques that will empower you to create even more powerful and polished GUI applications. Throughout our exploration, we'll uncover invaluable tools such as the ttk module for enhanced widget styling, the Canvas widget for versatile graphics rendering, and the Grid geometry manager for precise layout control. From custom themes to file handling strategies, gear up to elevate your Tkinter expertise to the next level.

If you are new to Tkinter, I highly recommend you to thoroughly review this article or the official documentation. Familiarizing yourself with its contents will provide a solid foundation for understanding and effectively utilizing Tkinter.

In the code snippets provided, add these lines in the beginning:

import tkinter as tk
from tkinter import ttk
window = tk.Tk()
window.geometry("457x335")

and this line at the end:

window.mainloop()

Custom Styles and Themes

Tkinter enables customized visual presentation through custom styles and themes, using the ttk module for personalized widget designs, ensuring consistency across platforms.

To deepen our understanding, let's personalize our textbox, button, and label by customizing their appearance:

import tkinter as tk
from tkinter import ttk

def submit_text():
    text = text_entry.get()
    text_label.config(text=text, font=("Times New Roman", 12, "bold"), foreground="green")     #customize label

window = tk.Tk()
window.geometry("457x335")
window.title("Custom Styles")

style = ttk.Style()     #to define custom styles
style.configure("Custom.TEntry", foreground="blue", fieldbackground="lightblue")     #customize textbox
style.configure("Custom.TButton", foreground="red", background="red")     #customize button

text_entry = ttk.Entry(window, width=30, style="Custom.TEntry")
text_entry.pack(padx=10, pady=10)
submit_button = ttk.Button(window, text="Submit", command=submit_text, style="Custom.TButton")     #sends entered text to the submit_text() function
submit_button.pack(padx=10, pady=5)
text_label = ttk.Label(window)
text_label.pack(padx=10, pady=10)
window.mainloop()

The submit_text function retrieves your text from the text_entry textbox and updates the text_label with it. The label's appearance is customized using Times New Roman font, size 12, bold, and green color. Custom styles (Custom.TEntry for the textbox and Custom.TButton for the button) are defined and configured using the ttk.Style() method to set properties like foreground and background colors.

Integration with Python Libraries

Tkinter can be integrated with other Python libraries and tools to enhance its functionality:

Integration with Matplotlib: You can make your Tkinter app more informative by adding interactive charts to display data trends or visualizations. By integrating Matplotlib, a popular Python library for creating charts and graphs, you can easily embed dynamic plots directly into your Tkinter windows.
Integration with Scikit-learn: You can combine Tkinter with Scikit-learn to develop GUI applications for machine learning tasks such as classification, regression, and clustering. This integration enables us to build interactive interfaces for training models, evaluating performance, and making predictions.

Note: In order to install sklearn library locally, run the command: `pip install scikit-learn`

Caution: Ensure local compatibility by installing `matplotlib` and `matplotlib.backends.backend_tkagg` before running this code.

Let's delve into the concept using an example of Linear Regression applied to predict outcomes for the Diabetes dataset:

import tkinter as tk
from tkinter import ttk     #for themed widgets
import matplotlib.pyplot as plt
from sklearn.datasets import load_diabetes
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error

diabetes = load_diabetes()     #Load the dataset
X_train, X_test, y_train, y_test = train_test_split(diabetes.data, diabetes.target, test_size=0.2, random_state=42)

window = tk.Tk()
window.geometry("650x500")
window.title("Diabetes Linear Regression")

def train_and_plot():
    model = LinearRegression()
    model.fit(X_train, y_train)     #train
    y_pred_train = model.predict(X_train)     #predict
    y_pred_test = model.predict(X_test)
    mse_train = mean_squared_error(y_train, y_pred_train)     #calculate mean squared error
    mse_test = mean_squared_error(y_test, y_pred_test)
    
    plt.figure(figsize=(8, 6))     #create the plot
    plt.scatter(y_test, y_pred_test, color='blue')
    plt.plot([min(y_test), max(y_test)], [min(y_test), max(y_test)], color='red', linestyle='--')
    plt.xlabel("Actual")
    plt.ylabel("Predicted")
    plt.title("Linear Regression Graph")
    plt.grid(True)
    plt.tight_layout()     #ensures the plot fits within the Tkinter window
    result_label.config(text=f"Train MSE: {mse_train:.2f}\tTest MSE: {mse_test:.2f}")
    canvas = FigureCanvasTkAgg(plt.gcf(), master=window)     #converts the plot into a format that can be displayed in the Tkinter window
    canvas.draw()
    canvas.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=1)     #adds the canvas widget to the Tkinter window.

train_button = ttk.Button(window, text="Train and Plot", command=train_and_plot)
train_button.pack(pady=10)
result_label = ttk.Label(window, text="")
result_label.pack()
window.mainloop()

The train_and_plot function trains a linear regression model on the dataset, predicts the target values, calculates the mean squared error for both training and testing sets, and then plots the predicted values against the actual values using matplotlib. It also displays the calculated mean squared errors on your GUI window.

Advanced Widgets

Tkinter provides a wide range of widgets beyond the basic ones like labels and buttons. You can explore and utilize widgets like treeview, notebook, progressbar, etc. to create sophisticated user interfaces.

A treeview to display hierarchical data, like a file explorer.

 import tkinter as tk
 from tkinter import ttk     #for themed widgets
 window = tk.Tk()
 window.geometry("640x300")
 tree = ttk.Treeview(window)
 tree["columns"] = ("Fruits", "Quantity")
 tree.heading("#0", text="Sr. No.")     #First column (index=0) will be Sr. No.
 tree.heading("Fruits", text="Fruits")
 tree.heading("Quantity", text="Quantity (kg)")
 tree.insert("", tk.END, text="1", values=("Apple", 30))
 tree.insert("", tk.END, text="2", values=("Orange", 25))
 tree.insert("", tk.END, text="3", values=("Mango", 29))
 tree.pack()
 window.mainloop()

The Treeview widget tree consists of two columns: "Fruits" and "Quantity (kg)". The heading method sets headings for each column, and the insert method adds items to the Treeview. Each item is inserted with a unique identifier "Sr. No." and its corresponding values for "Fruits" and "Quantity" are entered.

A notebook to organize your app into different tabs, like in a web browser.

 import tkinter as tk
 from tkinter import ttk     #for themed widgets
 window = tk.Tk()
 window.geometry("457x335")
 notebook = ttk.Notebook(window)
 tab1 = ttk.Frame(notebook)
 tab2 = ttk.Frame(notebook)
 tab3 = ttk.Frame(notebook)
 label1 = tk.Label(tab1, text="This is Tab 1")     #for tab 1
 label1.pack()
 entry2 = tk.Entry(tab2)     #for tab 2
 entry2.pack()
 check_var = tk.BooleanVar()
 check_button3 = tk.Checkbutton(tab3, text="This is Tab 3", variable=check_var)     #for tab 3
 check_button3.pack()
 notebook.add(tab1, text="Tab 1")
 notebook.add(tab2, text="Tab 2")
 notebook.add(tab3, text="Tab 3")
 notebook.pack()
 window.mainloop()

It creates a Notebook widget notebook, which allows 3 tabs to be displayed, namely Tab 1, Tab 2, and Tab 3, ceated using ttk.Frame. Tab 1 contains a Label widget with the text "This is Tab 1". Tab 2 contains an Entry widget for user input. Tab 3 contains a Checkbutton widget with the text "This is Tab 3".

A progressbar to show how far along a task is, like when you're downloading a file.

 import tkinter as tk
 from tkinter import ttk
 import time
    
 def start_task():
     progress_bar.start(10)     #start the progressbar (animation is updated every 10 milliseconds)
     window.after(3000, stop_task)     #simulate task completion after 3 seconds
    
 def stop_task():
     progress_bar.stop()      #stop the progressbar
    
 window = tk.Tk()
 window.geometry("457x335")
 progress_bar = ttk.Progressbar(window, orient="horizontal", length=200, mode="indeterminate")
 progress_bar.pack()
 start_button = tk.Button(window, text="Start Task", command=start_task)
 start_button.pack(pady=20)
 window.mainloop()

When the "Start Task" button is clicked, it triggers the start_task function, which starts the progress bar animation using the start method. The after method is used to schedule the stop_task function to run after 3 seconds. The stop_task function stops the progress bar animation using the stop method.

Advanced Layout Management

Advanced Layout Management can be used to make your Tkinter app look polished. Layout management helps you move widgets around and make your app look just the way you want using grid, place, and pack managers.

Grid
You can place widgets in rows and columns, and they will organize neatly into place.

  import tkinter as tk
  window = tk.Tk()
  window.geometry("457x335")
  label1 = tk.Label(window, text="Subject")
  label2 = tk.Label(window, text="Marks")
  entry1 = tk.Entry(window)     #Widgets
  entry2 = tk.Entry(window)
  entry3 = tk.Entry(window)
  entry4 = tk.Entry(window)
  label1.grid(row=0, column=0)     #Layout
  label2.grid(row=0, column=1)
  entry1.grid(row=1, column=0)
  entry2.grid(row=1, column=1)
  entry3.grid(row=2, column=0)
  entry4.grid(row=2, column=1)
  window.mainloop()

This code sets up 2 labels Subject and Marks and 4 entry widgets for data input. The layout is organized with Subject in row 0, column 0, Marks in row 0, column 1. Entry widgets entry1 and entry2 occupy row 1, columns 0 and 1 respectively, while entry3 and entry4 are in row 2, columns 0 and 1.

Pack
You can stack widgets on top of each other or arrange them side by side, and Tkinter will figure out how to fit them all in.

  import tkinter as tk
  window = tk.Tk()
  window.geometry("457x335")
  button1 = tk.Button(window, text="Left")     #Widgets
  button2 = tk.Button(window, text="Top")
  button3 = tk.Button(window, text="Right")
  button4 = tk.Button(window, text="Bottom")
  button1.pack(side=tk.LEFT)     #Layout
  button2.pack(side=tk.TOP)
  button3.pack(side=tk.RIGHT)
  button4.pack(side=tk.BOTTOM)
  window.mainloop()

The buttons button1, button2, button3 and button4 are positioned by providing the side parameter with values tk.LEFT, tk.TOP, tk.RIGHT, or tk.BOTTOM respectively.

Place
You can specify exactly where you want each widget to go by giving it coordinates, like x and y coordinates on a graph.

  import tkinter as tk
  window = tk.Tk()
  window.geometry("457x335")
  label1 = tk.Label(window, text="x_50_y_50")     #Widgets
  label2 = tk.Label(window, text="x_200_y_200")
  label1.place(x=50, y=50)     #Layout
  label2.place(x=200, y=200)
  window.mainloop()

The place method is used to position label widgets. label1 is placed at coordinates (50, 50), and label2 is placed at coordinates (200, 200).

File Handling

Tkinter facilitates file handling through the filedialog tool, enabling users to interactively select files on their computer. With this feature, your application can support tasks like creating, opening, saving, and editing various file types such as documents, images, or spreadsheets.

Let's understand this using an example:

import tkinter as tk
from tkinter import filedialog

def open_file():
    file_path = filedialog.askopenfilename()     #opens a dialog window to select an existing file or create a new one
    if not file_path:
        return
    with open(file_path, 'a+') as file:     #'a+' to append the text to the file
        file.write("January\n")
        file.write("February\n")
        file.write("March\n")
        file.write("April\n")
        file.write("May\n")
    status_label.config(text=f"File '{file_path}' has been written and closed.")

window = tk.Tk()
window.geometry("457x335")
window.title("File Writer")
open_button = tk.Button(window, text="Open a File", command=open_file)
open_button.pack(pady=20)
status_label = tk.Label(window, text="")
status_label.pack()
root.mainloop()

When clicked, the button "Open a File" triggers the open_file function, which opens a dialog window allowing you to select an existing file or create a new one. If a file is selected, the code appends the strings "January", "February"..."May" to the file and the file is closed. The status_label is then updated to display a message confirming the file write operation.

Note: The file will automatically be closed when the `with` block is exited. However, you may explicitly close the file by calling `file.close()`.

Tkinter offers both modal and modeless dialogs, ideal for user input, confirmation messages, or notifications. The tkinter.messagebox module provides standard message boxes, while custom dialog windows can be created using Toplevel widgets.

Modal dialogs are windows that require the user to interact with them before returning to the main application window. They typically block interaction with other windows in the application until they are closed.

  import tkinter as tk
  from tkinter import messagebox

  def show_modal_dialog():
      messagebox.showinfo("Modal Dialog", "Pay attention to this dialog box!")     #does not let you proceed until you click the "OK" button

  window = tk.Tk()
  window.geometry("457x335")
  window.title("Modal Dialog Example")
  modal_button = tk.Button(window, text="Click me", command=show_modal_dialog)
  modal_button.pack(padx=20, pady=10)
  window.mainloop()

Modeless dialogs are windows that allow the user to interact with both the dialog and the main application window simultaneously. They do not block interaction with other windows in the application, allowing the user to switch between them freely.

  import tkinter as tk

  def show_modeless_dialog():
      modeless_dialog = tk.Toplevel(window)     #allows you to interact with other open windows
      modeless_dialog.title("Modeless Dialog")
      modeless_dialog.geometry("250x100")
      label = tk.Label(modeless_dialog, text="Have a nice day!")
      label.pack(padx=20, pady=10)

  window = tk.Tk()
  window.geometry("457x335")
  window.title("Modeless Dialog Example")
  modeless_button = tk.Button(window, text="Click me", command=show_modeless_dialog)
  modeless_button.pack(padx=20, pady=10)
  window.mainloop()

When clicked, the button "Click me" triggers the show_modeless_dialog function, which creates a modeless dialog box using the Toplevel widget. It will not hinder your interaction with the other windows.

Tip: Using a class for modeless dialogs can organize and encapsulate dialog functionality, particularly for more intricate dialogs with multiple components and interactions.

Conclusion

Tkinter is a versatile Python GUI framework that enhances user interaction and functionality. With features like custom themes, threading, file handling, dialogs, layout management, advanced widgets, and integration with libraries like Matplotlib and scikit-learn, Tkinter empowers developers to create dynamic desktop applications. By leveraging these capabilities, developers can craft unique GUIs that elevate user experience, making Tkinter a top choice for Python GUI projects.

Building a Calculator using tkinter

Tue, 02 Apr 2024 20:46:16 +0000

When working on a basic calculator with Tkinter, a widely-used GUI toolkit for Python, Tkinter streamlines the incorporation of user-friendly elements such as buttons, entries, grids, and custom styles that are necessary for crafting graphical user interfaces, making it particularly well-suited for applications. Its simplicity and efficiency in managing user interactions make it an ideal choice for projects of this nature.

Creating the Calculator

Now let us actually dive into the process of building the calculator, one step at a time. All the required steps are given below; follow them one by one, and you will be able to develop an efficient and interactive calculator.

Step 1: Setting Up Environment

Before we start building our calculator, ensure that you have Python installed on your system. To do so, the following section gives a short guide on the steps to be followed for different platforms.

For Windows:

Download and install Python from the official website
Verify by running the following command:
```
 python --version
```

For Linux:

Open terminal and copy and paste the code

 sudo apt-get update
 sudo apt-get install python3

Once installed verify by running the following command
```
 python --version
```

For MacOs:

Download and install Python from the official website
For reference Steps to install python on MacOs

Next, we need to install Tkinter, which is included with Python by default. So, there's no need to install it separately

Step 2: Importing Libraries

In Python, the tkinter module is used for creating GUI applications.
Now let's import these required libraries along with other required modules:

import tkinter as tk
from tkinter import messagebox

Explanation

tkinter: This module provides classes and functions for creating GUI applications.

messagebox: This submodule allows us to display message boxes for showing information or prompting the user for confirmation.

Step 3: Creating the Calculator Class

Create a class called class Calculator that will represent our calculator application:

class Calculator:
    def __init__(self, master):
        self.master = master
        self.master.title("Simple Calculator")
        self.master.geometry("300x400")
        self.master.resizable(False, False)
        self.create_widgets()

    def create_widgets(self):
        # Create entry widget for displaying input and results
        self.entry = tk.Entry(self.master, width=20, font=('Arial', 14), bd=5, justify="right")
        self.entry.grid(row=0, column=0, columnspan=4, padx=10, pady=10)

        # Define buttons
        buttons = [
            ('7', 1, 0), ('8', 1, 1), ('9', 1, 2), ('/', 1, 3),
            ('4', 2, 0), ('5', 2, 1), ('6', 2, 2), ('*', 2, 3),
            ('1', 3, 0), ('2', 3, 1), ('3', 3, 2), ('-', 3, 3),
            ('0', 4, 0), ('.', 4, 1), ('=', 4, 2), ('+', 4, 3)
        ]

        # Create buttons using a loop
        for (text, row, col) in buttons:
            button = tk.Button(self.master, text=text, width=5, height=2, 
            font=('Arial', 14), command=lambda t=text: self.on_button_click(t))
            button.grid(row=row, column=col, padx=5, pady=5)

Initialization

The init method in the Calculator class sets up the basic features of the calculator when it's first created. It's like laying out the blueprint for how the calculator will look and work. The master part helps position the calculator in the right place on the screen. self.master.title("Simple Calculator") gives the calculator window a name, like "Simple Calculator". The self.master.geometry("300x400") part determines how big the calculator window will be, making sure it's neither too small nor too big. The lineself.master.resizable(False, False) prevents users from changing the size of the calculator window, keeping it neat and tidy. Finally, self.create_widgets() starts the process of actually creating all the buttons and numbers you see on the calculator screen. It's like setting up the stage before the show begins. So, with all these steps, the calculator is ready to go when you open it up!

Widget Creation

The create_widgets method orchestrates the construction of the calculator's user interface, beginning with the establishment of an entry widget named self.entry for displaying input and results, meticulously configured with specific attributes such as width, font size, border width, and text alignment. Positioned within the window using the grid method, this entry widget ensures clarity and organization of numerical data. Subsequently, utilizing a list named buttons containing tuples of button details, the method dynamically generates button widgets for each entry within the list. These buttons, equipped with attributes such as text labels and dimensions, are seamlessly integrated into the window using the grid method, with each button assigned a command to execute the on_button_click method upon interaction, passing the corresponding button text as an argument. Through meticulous placement and configuration, the create_widgets method establishes a coherent and functional user interface, essential for intuitive interaction and efficient calculation.

Step 4: Implementing Button Click Functionality

Next, we define the on_button_click() method to handle button clicks:

def on_button_click(self, text):
     if text == '=':
          try:
              result = eval(self.entry.get())
              self.entry.delete(0, tk.END)
              self.entry.insert(tk.END, str(result))
          except Exception as e:
              messagebox.showerror("Error", "Invalid Input")

          elif text == 'C':
              self.entry.delete(0, tk.END)

          else:
              self.entry.insert(tk.END, text)

Explanation:

In this block of code, several conditional statements and actions are executed based on the text of the clicked button within the calculator interface. First, there's a check to see if the button text is equal to '=' (the equal sign). If so, the mathematical expression entered in the entry widget (self.entry) is evaluated using the eval() function, and the result is stored in the result variable. The contents of the entry widget are then cleared using self.entry.delete(0, tk.END), and the calculated result is inserted into the entry widget using self.entry.insert(tk.END, str(result)). In case an exception occurs during evaluation, it's caught using a try-except block, and an error message box is displayed using messagebox.showerror("Error", "Invalid Input"). Lastly, the text of the clicked button is inserted into the entry widget at the end (tk.END) using self.entry.insert(tk.END, text), allowing users to append their input string. These actions ensure proper functionality and user feedback within the calculator interface, facilitating smooth interaction and accurate computation.

Step 5: Driver Function

Lastly, we need to create an instance of the Calculator class and run the main event loop:

 if __name__ == "__main__":
     root = tk.Tk()
     app = Calculator(root)
     root.mainloop()

Explanation:

The line if __name__ == "__main__" serves as a conditional statement that ensures that the subsequent code block is executed only if the Python script is directly run by the interpreter, rather than being imported as a module into another script. Following this condition, root = tk.Tk() initializes a new instance of the Tkinter Tk class, establishing the main window or root window for the graphical user interface (GUI) application. This window acts as a container for all other GUI elements to be displayed. Subsequently, app = Calculator(root) creates an instance of the Calculator class, utilizing the root window as an argument, thereby initializing the calculator application within this main window. Lastly, root.mainloop() initiates the Tkinter event loop, a critical component that continuously listens for user interactions, such as button clicks and window resizing, effectively maintaining the responsiveness of the GUI. This function call essentially blocks further script execution until the main window is closed by the user, ensuring the seamless functioning of the GUI application.

Step 6: Outcome of Implementation

Code snippet

import tkinter as tk
from tkinter import messagebox

class Calculator:
    def __init__(self, master):
        self.master = master
        self.master.title("Simple Calculator")
        self.master.geometry("300x400")
        self.master.resizable(False, False)
        self.create_widgets()

    # creating the widgets
    
    def create_widgets(self):
        # Create entry widget for displaying input and results
        self.entry = tk.Entry(
            self.master, width=20, font=("Arial", 14), bd=5, justify="right"
        )
        self.entry.grid(row=0, column=0, columnspan=4, padx=10, pady=10)

        # Define buttons
        buttons = [
            ("7", 1, 0),
            ("8", 1, 1),
            ("9", 1, 2),
            ("/", 1, 3),
            ("4", 2, 0),
            ("5", 2, 1),
            ("6", 2, 2),
            ("*", 2, 3),
            ("1", 3, 0),
            ("2", 3, 1),
            ("3", 3, 2),
            ("-", 3, 3),
            ("0", 4, 0),
            (".", 4, 1),
            ("=", 4, 2),
            ("+", 4, 3),
        ]

        # Create buttons using a loop
        for text, row, col in buttons:
            button = tk.Button(
                self.master,
                text=text,
                width=5,
                height=2,
                font=("Arial", 14),
                command=lambda t=text: self.on_button_click(t),
            )
            button.grid(row=row, column=col, padx=5, pady=5)

    # funtion creation for on click feature
    def on_button_click(self, text):
        if text == "=":
            try:
                result = eval(self.entry.get())
                self.entry.delete(0, tk.END)
                self.entry.insert(tk.END, str(result))
            except Exception as e:
                messagebox.showerror("Error", "Invalid Input")

        elif text == "C":
            self.entry.delete(0, tk.END)

        else:
            self.entry.insert(tk.END, text)

    # main funtion is defined                
    if __name__ == "__main__":
        root = tk.Tk()
        app = Calculator(root)
        root.mainloop()

Understanding Code Functionality

When the calculator starts, it creates a window with an entry widget. This widget is where you can input numbers and view the results.
The calculator has buttons for digits from 0 to 9, the decimal point '.', and arithmetic operations like addition '+', subtraction '-', multiplication '*', and division '/'. These buttons are arranged in a grid layout.

Tip: Implement input validation to avoid potential security vulnerabilities or crashes.

When a button is clicked, it triggers the on_button_click function. If the button is an arithmetic operation or a digit, it adds that value to the entry widget. If the button is '=' (equal sign), it evaluates the expression in the entry widget and displays the result. If it's 'C' (clear), it clears the entry widget.
When '=' is pressed, it tries to evaluate the expression entered in the entry widget using Python's eval() function. If the expression is valid, it computes the result and displays it in the entry widget. If there's an error, such as invalid input or division by zero, it shows an error message.

Warning: Avoid using the eval() function with untrusted input to prevent code injection vulnerabilities.

The program keeps running in a loop, waiting for user interactions, until the window is closed.
Users can input numbers and perform arithmetic operations by clicking the respective buttons. They can clear the input by clicking 'C' and get the result by clicking '='.

Calculator Functionality Flowchart

Following is an illustration of the functionality of a simple calculator program through a clear and logical flowchart.

Testing Result

Possible Errors that might occur

In building a calculator using Tkinter, potential errors include syntax mistakes, input validation issues, and challenges with complex operations. Effective debugging is crucial for ensuring the calculator functions reliably. Have a look at some of the problems along with their solutions that are listed below.

Division by zero error:

Problem: If the user divides by zero, Python will raise a ZeroDivisionError.

Solution: Handle division by zero within the try-except block.

try:
    result = eval(self.entry.get())
    if result == float('inf'):
         messagebox.showerror("Error", "Division by zero")
    else:
        self.entry.delete(0, tk.END)
        self.entry.insert(tk.END, str(result))

Syntax error in evaluation:

Problem: If the user enters an invalid expression that can't be evaluated, it will raise a SyntaxError.

Solution: Catch SyntaxError and display an appropriate error message.

except SyntaxError:
messagebox.showerror("Error", "Invalid Expression")

NameError due to undefined variable:

Problem: The code checks for the '=' and 'C' buttons, but they're not defined in the button list.

Solution: Add the '=' and 'C' buttons to the list with their respective positions.

buttons = [
   ...
   ('=', 4, 2), ('C', 4, 0)
]

Missing import statement:

Problem: The code uses messagebox without importing it.

Solution: Import messagebox from tkinter.

from tkinter import messagebox

Unsupported operations:

Problem: The calculator allows arbitrary evaluation of expressions using eval(), which can lead to unintended consequences.

Solution: Restrict the input to a certain format or implement a safer method for evaluation, such as parsing the expression manually.
Here's a safer approach to evaluate expressions using ast.literal_eval():

import ast
def evaluate_expression(self, expression):
    try:
        return ast.literal_eval(expression)
    except (SyntaxError, ValueError):
        raise ValueError("Invalid expression")
  
def on_button_click(self, text):
    if text == '=':
        try:
            result = self.evaluate_expression(self.entry.get())
            self.entry.delete(0, tk.END)
            self.entry.insert(tk.END, str(result))
        except ValueError as e:
            messagebox.showerror("Error", str(e))

Conclusion:

In conclusion, developing a simple calculator using Tkinter in Python, offers a practical introduction to GUI application development. Tkinter's intuitive design, coupled with its cross-platform compatibility, empowers developers to create interactive interfaces effortlessly. By leveraging Tkinter's event-driven model, we constructed a calculator with basic arithmetic operations, error handling, and clear functionality. Utilizing widgets like Entry and Button, we orchestrated a user-friendly interface, enhancing accessibility and the user experience.

Throughout the process, we capitalized on object-oriented programming principles, encapsulating functionality within the Calculator class. This modular approach facilitates code organization and maintenance, promoting scalability and extensibility. Moreover, the integration of error handling mechanisms, such as try-except blocks and message boxes, underscores the importance of robustness in software design. These measures ensure graceful handling of unexpected inputs, enhancing the calculator's reliability and user confidence.

By adhering to best practices and leveraging Tkinter's capabilities, we've crafted a functional calculator application that demonstrates the synergy between Python's versatility and Tkinter's simplicity. This endeavor serves as a springboard for aspiring developers to delve deeper into GUI programming and explore the myriad possibilities of Python's ecosystem.

Tkinter library in Python

Tue, 12 Mar 2024 14:34:38 +0000

In this article, we'll dive into the world of Graphical User Interface (GUI) development using Python's Tkinter library. Tkinter stands as a versatile and user-friendly tool for beginners and advanced programmers alike, simplifying the creation of GUI applications. We aim to demystify the process of working with Tkinter, from understanding its core widgets to leveraging its strengths and navigating its limitations. By the end, you'll be equipped with the essentials of Tkinter to enhance your Python GUI development projects.

Understanding Tkinter

Tkinter, short for Tk interface, is a built-in Python library designed for creating interactive GUI applications. Tkinter, built on the Tk GUI toolkit, streamlines the creation of windows, buttons, menus, and other graphical elements. As an integral part of the Python standard library, Tkinter smoothly integrates with Python projects, requiring no extra installations, for a seamless GUI development experience. The official python tkinter documentation offers in-depth explanations of Tkinter modules, classes, and methods. Visit Documentation

Tip: As you embark on your GUI development journey, start by sketching out the design and functionality of your application before jumping into the code. This can save time and streamline your development process.

Exploring Basic Widgets

We'll begin by exploring some fundamental components you can construct using Tkinter. The following snippets must be preceeded by:

import tkinter as tk
window = tk.Tk()
window.geometry("457x335")

and followed by:

window.mainloop()

Caution: When working with widgets, remember to assign a unique name to each widget variable to avoid confusion, especially when your application starts to grow.

Label

Presents either text or an image, lacking interactive features for users. For more information on label refer official documentation of python.

label = tk.Label(window, text="This is a Label")
label.pack()

Button

An interactive component that executes a specific operation upon being clicked, like dispatching form data or activating a particular function.

def button_click():
    print("Button clicked")

button = tk.Button(window, text="Click here!", command=button_click)
button.pack()

After clicking the button:

Entry

A text field where users can input text or numbers. This component is frequently utilized for entering information or executing search operations.

entry = tk.Entry(window)
entry.pack()

Text

A text field that provides a multi-line text editing area for users to input or display text.

text = tk.Text(window, height=5, width=30)
text.pack()

Scale

Enables users to choose a value from a spectrum by moving a slider control. It is useful for selecting values like volume, brightness, etc.

def update_value(value):
    label.config(text=f"Volume Level: {value}")

scale = tk.Scale(window, from_=0, to=100, orient=tk.HORIZONTAL, command=update_value) #create a scale to select values from 0 to 100

scale.pack()
label = tk.Label(window, text="Volume Level: ")
label.pack()

Spinbox

A numerical input field with up and down arrow buttons for incrementing or decrementing the value.

spinbox = tk.Spinbox(window, from_=0, to=10)
spinbox.pack()

Separator

A horizontal or vertical line to visually separate sections or groups of widgets.

from tkinter import ttk #for themed widgets

label_1 = tk.Label(window, text="This is above the separator.")
label_1.pack()

separator = ttk.Separator(window, orient=tk.HORIZONTAL)
separator.pack(fill=tk.X)

label_2 = tk.Label(window, text="This is below the separator.")
label_2.pack()

Checkbutton

A checkbox enabling users to toggle between selecting and deselecting an option.

check_var = tk.BooleanVar() #To keep track of the checkbox's state (checked or unchecked)
check_button = tk.Checkbutton(window, text="Checkbox", variable=check_var)
check_button.pack()

Radiobutton

A group of radio buttons, ensuring that users can select only one option from a list of choices.

radio_var = tk.StringVar() #To track which radio button is selected
radio_1 = tk.Radiobutton(window, text="Option 1", variable=radio_var, value="Option 1")
radio_2 = tk.Radiobutton(window, text="Option 2", variable=radio_var, value="Option 2")
radio_1.pack()
radio_2.pack()

Listbox

A widget presenting a list of items, allowing users to select one or more options from the list.

Scrollbar

Permits users to navigate through content surpassing the widget's visible boundaries, like in a text field or list.

listbox = tk.Listbox(window)
scrollbar = tk.Scrollbar(window)
scrollbar.pack(side=tk.RIGHT, fill=tk.Y) #scrollbar will be at the right side of the window and expands vertically
listbox.pack(side=tk.LEFT, fill=tk.BOTH) #listbox will be at the left side of the window and expands horizontally and vertically
listbox.config(yscrollcommand=scrollbar.set) #Attach scrollbar to listbox
scrollbar.config(command=listbox.yview)

for i in range(30):
    listbox.insert(tk.END, f"Item {i+1}")

ColorChooser

A dialog for users to select a color. It provides a graphical interface for choosing colors using a palette or entering RGB values.

from tkinter import colorchooser

def choose_color():
    color = colorchooser.askcolor()
    print("Selected color:", color)

button = tk.Button(window, text="Choose Color", command=choose_color)
button.pack()

Frame

A container used to group and organize other widgets. It is frequently used for layout purposes, creating sections or divisions within a window.

frame = tk.Frame(window, bg="lightblue", bd=5)
frame.pack()

label = tk.Label(frame, text="Inside the Frame", bg="lightblue")
label.pack()

Canvas

Provides a drawing area for creating graphics, shapes, and custom elements. It is used for creating diagrams, charts, and interactive visualizations.

canvas = tk.Canvas(window, width=200, height=100, bg="white")
canvas.pack()
canvas.create_rectangle(50, 25, 150, 75, fill="red") #draw a red-coloured rectangle

PanedWindow

A container for arranging multiple panes or frames with adjustable sizes. It allows users to resize panes by dragging the divider between them.

paned_window = tk.PanedWindow(window, orient=tk.HORIZONTAL)
paned_window.pack(fill=tk.BOTH, expand=True) #will expand both horizontally and vertically
frame1 = tk.Frame(paned_window, width=228, height=200, background="red")
frame2 = tk.Frame(paned_window, width=228, height=200, background="blue")
paned_window.add(frame1)
paned_window.add(frame2)

After dragging the divider to the left:

Creates a menu bar or dropdown menu with options and commands. It is commonly used to include navigation, settings and additional functionalities into the application's interface.

def print_something():
    print("You chose the first option")

menu_bar = tk.Menu(window)

file_menu = tk.Menu(menu_bar, tearoff=0)
file_menu.add_command(label="Print Something", command=print_something)
file_menu.add_separator()
file_menu.add_command(label="Exit", command=window.quit)
menu_bar.add_cascade(label="Click to see options", menu=file_menu)
window.config(menu=menu_bar)

After selecting "Print Something":

These elements serve as fundamental components for Tkinter GUI applications, frequently employed across diverse projects to develop intuitive interfaces.

To delve deeper into Tkinter and explore its capabilities, you can start with the following sections of the Python documentation:

Tkinter — Python interface to Tcl/Tk: This section provides the foundational knowledge required to create GUI applications with Tkinter, including widget classes, event handling, and more Python Tkinter Documentation.

Graphical User Interfaces with Tk: This part of the documentation discusses the integration of Tk/Tcl with Python, offering insights into the architecture of Tkinter applications, the Tkinter module, and thematic widget extensions Python GUI with Tk.

Tkinter.ttk — Tk themed widgets: For those interested in using themed widgets for a more modern GUI look, this section details the thematic widget set provided by Tk 8.5 and integrated into Tkinter Themed Widgets.

Conclusion

Tkinter is a versatile and user-friendly toolkit for Python GUI development, offering a rich set of widgets, cross-platform compatibility, and seamless integration with Python code. Despite its limitations, Tkinter remains a popular choice for developers looking for efficient creation of simple to moderately complex GUI applications.

Coder Legion - Recent posts tagged library

Migrating a Real TypeScript OSS Library from tsup to tsdown 🔧

🤔 Why Migrate a Package That Already Builds Correctly?

📦 The Package Contract I Needed to Preserve

🛠️ The Migration Looked Almost Trivial

💥 The First Build Succeeded and Changed My Filenames

🔧 Fixing the Public Contract with outExtensions

🧪 Verifying the Published Package with a Smoke Test

📏 The Output Actually Got Bigger

⏱️ What About Build Performance?

🐱 Was the Migration Actually Small?

🎯 So, Was Moving from tsup to tsdown Worth It?

Handling Exceptions Like a Pro in Java

Handling Exceptions Like a Pro in Java: Stop Using catch-All Blocks

The Problem with Catch-Alls

Catch the Exact Thing You’re Solving

Move to Functional-Style Exception Handling

Checked vs Unchecked Exceptions — Handle Like You Mean It

♂️ Clean Exception Strategy

️ Bonus Tools That Help

Final thoughts

Clean Async State Management with Pinia Colada

What Is Pinia Colada?

Quick Start

Example: Querying Data

Mutations & Invalidation

Why You’ll Love It

Real-World Feedback

TL;DR – When to Use It

Want to Go Further?

Exploring More in Tkinter

Custom Styles and Themes

Integration with Python Libraries

Advanced Widgets

Advanced Layout Management

File Handling

Modal and Modeless Dialogs

Conclusion

Building a Calculator using tkinter

Creating the Calculator

Step 1: Setting Up Environment

Step 2: Importing Libraries

Step 3: Creating the Calculator Class

Step 4: Implementing Button Click Functionality

Step 5: Driver Function

Step 6: Outcome of Implementation

Code snippet

Understanding Code Functionality

Calculator Functionality Flowchart

Testing Result

Possible Errors that might occur

Division by zero error:

Syntax error in evaluation:

NameError due to undefined variable:

Missing import statement:

Unsupported operations:

Conclusion:

Tkinter library in Python

Understanding Tkinter

Exploring Basic Widgets

Label

Button

Entry

Text

Scale

Spinbox

Separator

Checkbutton

Radiobutton

Listbox

Scrollbar

ColorChooser

Frame

Canvas

PanedWindow

Menu

Conclusion

🔧 Fixing the Public Contract with `outExtensions`