Two of the most popular are:

• NSIS - https://nsis.sourceforge.io/Main_Page

• Inno Setup - http://www.jrsoftware.org/isinfo.php

For this chapter, you will be using Inno Setup. You will also be learning about the following topics:

• Installing Inno Setup

• Creating an Installer

• Testing Your Installer

Let’s get started by learning to install the installer!

Installing Inno Setup

Installing Inno Setup is pretty simple. You will need to go to the following URL:

• http://www.jrsoftware.org/isinfo.php

Then go to the Download Inno Setup link and choose where you want to download the application from. After downloading Inno Setup, double-click the installer to install it on your system.

Now that you have Inno Setup installed on your Windows machine, you can create your own installer!

Creating an Installer

The first step in creating an installer is to choose what you want to install. For this example, you will use the image viewer executable that you created in the previous chapter.

Inno Setup makes creating an installer really straightforward. It uses a wizard that walks you through it step by step. To get started, run Inno Setup and you should see a screen that looks like this:

While Inno Setup defaults to opening an existing file, what you want to do is choose the second option from the top: “Create a new script file using the Script Wizard”. Then press OK.

You should now see the first page of the Inno Setup Script Wizard:

Go ahead and hit Next here. You will now be on the Application Information page:

This is where you enter your application’s name, its version information, the publisher’s name and the application’s website. You can fill it out to match the screenshot or customize it to your specifications.

Once you are finished, press Next and you should see the following:

This page of the wizard lets you set the application’s installation directory. On Windows, most applications install to Program Files, which is also the default here. This is also where you set the folder name for your application. This is the name of the folder that will appear in Program Files. Alternatively, you can check the box at the bottom that indicates that your application doesn’t need a folder at all.

You can edit this page if you don’t like the defaults. Otherwise, press Next to continue:

Here is where you will choose the main executable file. In this case, you want to choose the executable you created with PyInstaller. If you didn’t create the executable using the --onefile flag, then you can add the other files using the Add file(s)... button. If your application requires any other special files, like a SQLite database file or images, this is also where you would add them.

Note: Remember on Windows 10, if you used --onefile, then you also need to sign the file or it will be marked as malware by Windows Defender.

By default, this page will allow the user to run your application when the installer finishes. Many installers do this, so it’s expected by most users.

When you are done, click Next to go to the Shortcuts page:

This is the Application Shortcuts page and it allows you to manage what shortcuts are created for your application and where they should go. The options are pretty self-explanatory. You can usually use the defaults, but you are welcome to change them however you see fit.

Once you are finished configuring the shortcuts, press Next to continue:

The Documentation Page of the wizard is where you can add your application’s license file. For example, if you were putting out an open source application, you can add the GPL or MIT or whatever license file you need there. If this were a commercial application, you would add your End-User License Agreement (EULA) file here. You can also add some extra information before and after the installation here too!

All these files are optional. If you don’t want to apply a license or add before-and-after instructions, you can just click Next.

This page specifies which install mode to use when installing your application. The default is to install for all users, which is probably what you want. The other options are pretty self-explanatory. You can play around with them or read more about them in Inno Setup's documentation. Once you're done with this page, go on to the next one.

Here you can set up which languages should be included in your installer. The default is English, but Inno Setup supports many others. Feel free to modify this as needed before continuing on.

The Compiler Settings page lets you name the output setup file, which defaults to simply setup. You can set the output folder here, add a custom setup file icon and even add password protection to the setup file. I usually just leave the defaults alone, but this is an opportunity to add some branding to the setup if you have a nice icon file handy.

The next page is for the preprocessor:

The preprocessor is primarily for catching typos in the Inno Setup script file. It basically adds some helpful options at compile time to your Inno Setup script.

Check out the following URL for full details:

• http://www.jrsoftware.org/ispphelp/

When you press Next you will reach the final page of the wizard:

There's nothing to do here but press Finish, Back or Cancel. Go ahead and complete the wizard by pressing Finish:

Inno Setup now asks you if you would like to compile the script. This means that Inno Setup has created a build script for your installer and would like your permission to run that script to actually create your installer executable. Press Yes to continue.

This dialog asks if you would like to save the Inno Setup compiler script before running it. That is certainly a good idea as you don’t want to lose any of your changes. Press Yes to save it and then choose what to name the script and where to save it.

Once the script is saved, it will create your installer. At this point you should have an installer created! You can edit the script file in any text editor, although the Inno Setup editor is probably best as it has its own syntax highlighting built-in to it.

Testing Your Installer

Now that you have an installer, it’s a good idea to test it. When you finish building the installer with Inno Setup, it will automatically run the installer for you. You can choose to install your application now and verify that it launches correctly.

You may see an error when you attempt to run your application. That usually means that you forgot to include some file or other in your installer. Occasionally you will get errors that are related to permission issues. You can solve the first issue by comparing what files were installed to the ones in your dist folder that you created with PyInstaller. If there are any missing, you can run Inno Setup and go through the wizard again or you can modify the script file yourself directly.

Permission issues are more difficult and will take some trial and error to figure out. You will likely need to research what exactly the problem is to figure out how to solve it.

Of course, occasionally there’s something wrong with the executable itself. Then you’ll have to debug it before you can repackage it into an installer.

Wrapping Up

Creating an installer for your Windows users is a good idea. Having an installer gives the users confidence in your program. Installers add that extra bit of polish and they make it easier to make sure all the files you need are installed with your application.

In this chapter, you learned about:

• Installing Inno Setup

• Creating an Installer

• Testing Your Installer

You should spend some time reading the Inno Setup documentation and then trying it out on some of your own creations. You will quickly find that Inno Setup is intuitive and you’ll soon have some installers of your own.

The grid layout doesn’t even use containers. You control the layout completely with CSS. To create complex layouts, individual widgets can span multiple rows, columns, or both.

Here is a drawing that demonstrates some of what you could do with a grid layout:

Textual grid layouts should NOT be confused with CSS Grids. Those are from the web development world and have little in common with what you will be doing with Textual.

When you want to grid layout in Textual, you will define the number of rows and columns that your grid needs to have using the grid-size CSS property. You will also need to set the layout: grid to apply the grid layout. At that point, widgets get added to the grid’s cells from left to right and then top to bottom.

You will start by creating a layout without CSS to demonstrate again what happens when you do not have a layout defined. Open up your Python editor and create a new file with the following code:

This code creates an application with four buttons, but they use Textual's default layout strategy. When you run this code, you will see this:

That’s obviously not a grid! You will need to rewrite the code to use a CSS grid layout instead.

First, create some CSS. Create a new file called grid.tcss and add the following:

The CSS above will create a 2x3 grid with two columns and three rows. You will also set the height and width of the buttons so that they fill the “cells”.

Your grid has six cells, but you do not need to fill all of them. For this example, you will fill the first four cells. Open up your Python editor and create a grid.py file. Then enter the following code:

Your code will fill in the first four cells in your grid. The first two buttons go in the first row. Once that row is full, Textual will add the following widgets to the next row.

When you run this code, you will see something similar to this:

What will happen if you add a fifth button? Try it out and see! You should get something like this:

Now, you’re ready to learn how to adjust the sizes of your columns and rows!

Modifying Row and Column Sizes

You can make rows and columns have different relative widths or heights. This is a great way to make one row or column larger than another. Again, you do this in the CSS file.

You can adjust the rows and columns using the following parameters:

• grid-columns

• grid-rows

In your CSS file, you have a 2-column by 3-row grid. Create a new CSS file named row_adjust.css and add the following code to it:

Everything here is the same except for the third parameter to Screen, which defines the grid-rows. Here, you set the first row to take up 50% of the space, and the other two rows to each take up 25%.

You must update your code to utilize your new CSS file. To keep things from getting confusing, create a new file named row_adjust.py and add this code to it:

The only change here is to update the CSS_PATH to point to the new CSS file. When you run this code, you will see this:

As expected, the first row in the grid is twice as high as the other two rows that follow it.

Note: If you do not specify enough values to match your rows or columns, then Textual will use the values you provided and repeat them. That means that if you have four columns in your grid but specify grid-columns: 3 2 then Textual will update it internally to be grid-columns: 3 2 3 2.

Automatic Row and Column Sizing

Textual also provides a way to set your column or row rules to resize based on the content in the widget automatically. You can use the string “auto” instead of specifying a unit or percentage size constraint. When you do that, Textual does the calculating for you.

Here’s an example in CSS where you set column one to be automatically sized:

The second column in the CSS above is set to 1fr, so it fills the remaining space.

You need to create some Python code to see this CSS in action. Open up a new Python file and name it auto.py:

Here you create a set of four buttons as before. However, the first button in this code has an absurdly long label. When you run this code, the column resizes to fit that button's label within it:

Try updating the label to something shorter or longer and re-run the code. It’s good practice, and you’ll learn more by modifying the code yourself.

Spanning Cells

The real power of grids comes into play when you learn how to make a widget span cells. You can stretch a widget across multiple columns, rows, or both! You can control cell spanning using the following directives:

• column-span - followed by the number of columns to span across

• row-span - followed by the number of rows to span across

To make a specific widget span across cells, you need a way to select that widget in CSS. The easiest way to select a widget is to give it a unique identifier or ID.

You will see how this works by writing some CSS code where you select a widget with the id of “one”. You may recall that the way you select an id is to use the octothorpe or hash-tag character followed by the id name. So, in the case of a tag called “one”, you would use #one.

Create a new CSS file in your text editor called col_span.tcss and enter the following code:

The CSS code will make the widget with the id of “one” span across two columns. Also set the widget’s tint to blue so it stands out more. You also set the grid to be 3x3 instead of 2x3, so keep that in mind. Now that you have the CSS code, it’s time to write some Python!

Open up your Python editor and create a new file called col_span.py, then enter this code into it:

The first button widget is the one you gave the ID “one”. The CSS will select that widget and make it span two columns.

Here is the result you will see when you run the code:

Try changing the number of columns spanned. You could also change the number of columns in the grid. Re-run the code after each change, or run it in developer mode so you can update the CSS in real time.

When you are done experimenting, go back to your text editor and create a new file called row_span.tcss. Yes, it’s time you learned how to use row-span too!

Here’s the code:

For this example, you will make the widget with the id of “one” span two columns AND two rows!

The Python code is the same as before except for the update to which CSS_PATH you are using:

When you run this code, you will see this output:

Good job! You now know how to make one or more widgets span columns or rows.

Adding a Gutter

Grids can also have gutters! The gutter is the space between the cells in a grid. You can change the gutter spacing using the grid-gutter CSS property. Cells have no gutter by default if you do not set a gutter property. That means that the cell’s edges touch each other. On the other hand, if you set a gutter value, it applies to ALL cells! You can only use grid-gutter on a widget with layout: grid applied to it.

You can see how this works by creating a new CSS file. For this example, you will set the Screen widget’s background color to something other than black. You can use any color you want, but for this example, use yellow. When you set the button, the cells will have spacing between them, revealing the background color of the Screen underneath your other widgets.

You will name this CSS file gutter.tcss and use the following code in it:

Your CSS sets the grid-size to a 2x2 grid. You create a grid-gutter of 1 (one). In general, terminal cells are twice as tall as they are wide, so the cell spacing will look a little uneven.

Open up your Python editor and create a new file called gutter.py. Add this code to it:

When you run your code, you will see something like this:

The grid-gutter can also accept two values, which allow you to set the vertical and horizontal gutters, respectively. Since the cells are taller than they are wide, you can use a grid-gutter: 1 2 setting to get consistent-looking spacing around your cells. Give it a try and see for yourself!

Wrapping Up

Now you know all you need to know to do grid layouts effectively in Textual. You can use this knowledge to create complex user interfaces for your applications. Alternatively, you can use nested containers (see the previous article) to do something similar.

As always, spend time practicing what you have learned, and experiment with different values to see how they change your application's appearance.

Layouts with Containers

The Textual package has several utility containers you can use to lay out your widgets. You are most likely to use Vertical, Horizontal…

Read more

Each GUI or TUI toolkit provides a way to lay out your widgets. In this t…

Read more

Read more

Textual widgets support docking. When you dock a widget, the widget is removed from the layout and fixed in a static location. You can dock a widget to the following four positions:

• top

• right

• bottom

• left

A docked widget will not scroll out of view like widgets that are ins…

Read more

The biggest change is that plotest drawing is now done in a C++ kernel. The other big change is that plotext.figure is now the plot. Version 5 offered the same kind of thing, but in separate fun…

Read more

The reason this question has been in my mind is that I have run three Kickstarters for three different books in the last year. The first one was for my Vibe Coding Videogames book, which fai…

Read more

By plotting thes…

Read more

Using timeit

Python comes with a module called timeit. You can use it to time small code snippets. The timeit module uses platform-…

Read more

This chapter will cover the following topics:

• What is a decorator?

• Creating an exception logging decorator

• Passing a logger to a decorator

You wil…

Read more

Then, you break up your code into multiple files. In Python, each Python file is considered a module. A group of related modules is called a package.

Why does that m…

Read more

Read more

Python has continued to evolve, and it’s time for the book to evo…

Read more

Image brightness is a way to measure the intensity or luminosity of an image after it has been captured. Pillow’s ImageEnhance module allows you to modi…

Read more

Read more

Python has had type hinting support since Python 3.5, over TEN years ago! However, Python’s type annotations have changed repeatedly over the years. In Python Typing: Type Checking for Python Programmers, you…

Read more

Contrast is defined as the difference between dark and light in an image. A high-contrast image will have bright highlights and nice, dark shadows. Colors are usually bold and display texture. A low-contrast image, on the …

Read more

You can start learning the basics of Python with Python 101, or get more targeted learning with my book, Python Logging. If you want to create a user interface, then you might enjoy Creating T…

Read more

You can read more about these classes in the documentation.

In this article, you will focus only on adjusting an imag…

Read more