Textual: The Definitive Guide - Part 3.
Tags: python, programming, textual, rich
Published: 2022-04-17 20:24:26

---
cover_image: https://raw.githubusercontent.com/Textualize/textual/main/imgs/textual.png
---

Hello, puppies and kittens! In this article, we will carry on our series demystifying every damn aspect of Textual. In the previous articles, we built a series of increasingly complex applications to demonstrate some of the concepts associated with developing TUIs with Textual, such as reactive attributes, custom widgets, event handlers, and state management, among many others.

In part 1, we introduced the concept of a `GridView` view, and we didn't explain much about how it works to group and align widgets on a rectangular layout. In part 2, we created a useless dummy login form without actions, such as redirection from one widget to another and refreshing the terminal. We also explained how widget events are handled and how reactive attributes work in Textual, but we didn't explain how to make our app handle events fired by another widget, such as the submit button that we have created. And that's what we are going to explore in this article by creating a fully dynamic register/login form. 

Given the fact that textual is highly involved in object-oriented programming, this article assumes that you are already familiar with this concept. If not, consider reading [one of the most comprehensive tutorials out there](https://realpython.com/python3-object-oriented-programming/) about this topic. This article also assumes that you know the basics of SQL since it is used to do CRUD operations on the database for the login and register forms.

Throughout this article, two terms, "message" and "event" were used interchangeably and referred to the same thing.

This article will shed some light on numerous Textual concepts used when developing custom TUI applications:

• Creating a Textual widget with custom rendering capabilities and behavior.
• Using GridView to arrange widgets in terms of columns and rows on the terminal.
• Rerender widgets using Textual's built-in support for clearing and rerendering widgets.

**Spoilers ahead**: By the end of this article, you will learn how to create a fully functional login/register screen in Textual, as shown in the recording below.

![Login Form](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/tj0fv20j2wmzh46vcvq2.gif)

## 👉 Table Of Content (TOC). <a name="TOC"></a>

* [The Login Form](#LoginForm)
* [GridView](#GridView)
* [Views vs Layouts](#ViewsLayouts)
* [Storing User Credentials](#StoringCredentials)
* [Connecting The Database](#ConnectingDatabase)
* [Putting It All Together](#PuttingTogether)
* [Wrapping Up](#WrappingUp)
* [Future Work](#FutureWork)

## The Login Form <a name="LoginForm"></a>

##### 🔝 [Go To TOC](#TOC). 

In [part 2](https://dev.to/wiseai/textual-the-definitive-guide-part-2-6h8), we left off at [this snippet of code](https://dev.to/wiseai/textual-the-definitive-guide-part-2-6h8#submitbutton) that defines our login form logic.

It is made up of three main components: Two custom input widgets for entering username and password positioned at the top of the terminal and a submit button placed at the bottom of the terminal. Our submit button didn't do much other than logging the value of the username entered in a log file(notice the line `self.log(f"username = {self.username}")`). Now, we need to modify it to actually emulate the login process.

But first, let's tweak a bit the naming of some variables to reflect their functionalities and remove unnecessary variables.

```python
from rich.align import Align
from rich.box import DOUBLE
from rich.console import RenderableType
from rich.panel import Panel
from rich.style import Style
from rich.text import Text
from textual import events
from textual.app import App
from textual.reactive import Reactive
from textual.widget import Widget
from textual.widgets import Button
from textual.widgets import Button, ButtonPressed


class InputText(Widget):

    title: Reactive[RenderableType] = Reactive("")
    content: Reactive[RenderableType] = Reactive("")
    mouse_over: Reactive[RenderableType] = Reactive(False)

    def __init__(self, title: str):
        super().__init__(title)
        self.title = title

    def on_enter(self) -> None:
        self.mouse_over = True

    def on_leave(self) -> None:
        self.mouse_over = False

    def on_key(self, event: events.Key) -> None:
        if self.mouse_over == True:
            if event.key == "ctrl+h":
                self.content = self.content[:-1]
            else:
                self.content += event.key

    def validate_title(self, value) -> None:
        try:
            return value.lower()
        except (AttributeError, TypeError):
            raise AssertionError("title attribute should be a string.")

    def render(self) -> RenderableType:
        renderable = None
        if self.title.lower() == "password":
            renderable = "".join(map(lambda char: "*", self.content))
        else:
            renderable = Align.left(Text(self.content, style="bold"))
        return Panel(
            renderable,
            title=self.title,
            title_align="center",
            height=3,
            style="bold white on rgb(50,57,50)",
            border_style=Style(color="green"),
            box=DOUBLE,
        )


class MainApp(App):
    username: Reactive[RenderableType] = Reactive("")
    password: Reactive[RenderableType] = Reactive("")

    def handle_button_pressed(self, message: ButtonPressed) -> None:
        """A message sent by the submit button"""
        assert isinstance(message.sender, Button)
        button_name = message.sender.name
        if button_name == "login":
            self.username = self.username_field.content
            self.password = self.password_field.content
            # Query the username and password

    async def on_mount(self) -> None:
        self.login_button = Button(label="login", name="login")
        self.username_field = InputText("username")
        self.password_field = InputText("password")
        await self.view.dock(self.login_button, edge="bottom", size=3)
        await self.view.dock(self.username_field, edge="left", size=50)
        await self.view.dock(self.password_field, edge="left", size=50)


if __name__ == "__main__":
    MainApp.run(log="textual.log")
```

<figure>
  <img src="https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ui18b4cza6k148z94ue7.png">
  <figcaption>A wacky login screen.</figcaption>
</figure>

As you can tell, our login form looks wacky and a bit off proportions. We should organize the widgets in some sort of view. And that's what we are going to do in the next section.

## GridView <a name="GridView"></a>

##### 🔝 [Go To TOC](#TOC). 

As we saw in part 1 of the series, a grid lets us lay out our widgets in columns and rows. It is similar to [HTML tables](https://www.w3schools.com/html/html_tables.asp) for doing layouts. We are going to illustrate the various ways you can tweak a grid to arrange and organize your widgets on your terminal.

In textual, a `GridView` is one of many available views, but it has some powerful capabilities for different use cases.

As mentioned above, a `GridView` provides us a way to align widgets in rows and columns that indicate the relative position of widgets. For example, widgets with the same column will be stacked above each other. Similarly, Those in the same row will be adjacent to each other.

Column and row numbers should be positive integers. The width of each column is fixed and defined beforehand. Let's take the following snippet of code to demonstrate that:

```python
from textual.views import GridView

class LoginGrid(GridView):

    async def on_mount(self) -> None:
        self.grid.set_align("center", "center")
        self.grid.set_gap(1, 1)
        # Create rows / columns / areas
        self.grid.add_column("column", repeat=2, size=40)
        self.grid.add_row("row", repeat=3, size=3)
```

As you can tell, we have extended the base class `GridView` to create our custom `LoginGrid` grid. The code is pretty straightforward, it defiens a 2x3 grid with 40 characters width and 3 characters height for each column and row respectively(notice the `repeat` argument of `add_column` and `add_row`).

Now, Let's group our widgets within this grid which can be done by calling the `self.grid.add_widget` function on each widget. By doing so, our code will result in the following listing:

```python
from rich.align import Align
from rich.box import DOUBLE
from rich.console import RenderableType
from rich.panel import Panel
from rich.style import Style
from rich.text import Text
from textual import events
from textual.app import App
from textual.reactive import Reactive
from textual.views import GridView
from textual.widget import Widget
from textual.widgets import Button, ButtonPressed


class InputText(Widget):

    title: Reactive[RenderableType] = Reactive("")
    content: Reactive[RenderableType] = Reactive("")
    mouse_over: Reactive[RenderableType] = Reactive(False)

    def __init__(self, title: str):
        super().__init__(title)
        self.title = title

    def on_enter(self) -> None:
        self.mouse_over = True

    def on_leave(self) -> None:
        self.mouse_over = False

    def on_key(self, event: events.Key) -> None:
        if self.mouse_over == True:
            if event.key == "ctrl+h":
                self.content = self.content[:-1]
            else:
                self.content += event.key

    def validate_title(self, value) -> None:
        try:
            return value.lower()
        except (AttributeError, TypeError):
            raise AssertionError("title attribute should be a string.")

    def render(self) -> RenderableType:
        renderable = None
        if self.title.lower() == "password":
            renderable = "".join(map(lambda char: "*", self.content))
        else:
            renderable = Align.left(Text(self.content, style="bold"))
        return Panel(
            renderable,
            title="",
            title_align="center",
            height=3,
            style="bold white on rgb(50,57,50)",
            border_style=Style(color="green"),
            box=DOUBLE,
        )


class LoginGrid(GridView):
    username: Reactive[RenderableType] = Reactive("")
    password: Reactive[RenderableType] = Reactive("")

    async def on_mount(self) -> None:
        # define input fields
        self.username = InputText("username")
        self.password = InputText("password")
        self.grid.set_align("center", "center")
        self.grid.set_gap(1, 1)
        # Create rows / columns / areas
        self.grid.add_column("column", repeat=2, size=40)
        self.grid.add_row("row", repeat=3, size=3)
        # Place out widgets in to the layout
        button_style = "bold red on white"
        label_style = "bold white on rgb(60,60,60)"
        username_label = Button(label="username", name="username_label", style=label_style)
        password_label = Button(label="password", name="password_label", style=label_style)
        self.grid.add_widget(username_label)
        self.grid.add_widget(self.username)
        self.grid.add_widget(password_label)
        self.grid.add_widget(self.password)
        self.grid.add_widget(Button(label="register", name="register", style=button_style))
        self.grid.add_widget(Button(label="login", name="login", style=button_style))


class MainApp(App):
    username: Reactive[RenderableType] = Reactive("")
    password: Reactive[RenderableType] = Reactive("")

    def handle_button_pressed(self, message: ButtonPressed) -> None:
        """A message sent by the submit button"""
        assert isinstance(message.sender, Button)
        button_name = message.sender.name
        if button_name == "login":
            self.username = self.login_grid.username.content
            self.password = self.login_grid.password.content
            # Query username and password

    async def on_mount(self) -> None:
        self.login_grid = LoginGrid()
        await self.view.dock(self.login_grid)


if __name__ == "__main__":
    MainApp.run(log="textual.log")
```

Notice, we have added six widgets to our `LoginGrid` and two reactive attributes to store the username and password entered by the user and make them accessible to the parent application `MainApp`. The `add_widget` function will group the widgets from left to right, top to bottom. Now, our app looks minimalistic and contains only the `LoginGrid` inside the `on_mount` event handler. Running the above snippet of code will result in the following:

<figure>
  <img src="https://dev-to-uploads.s3.amazonaws.com/uploads/articles/xmy6vzjq54hrgox5elkk.png">
  <figcaption>A login screen.</figcaption>
</figure>

The comment `# Query username and password` is where we need to add the necessary logic to check whether or not the username and password being entered match a record in a database. For that purpose, we are going to use SQLite3 to store credentials since it comes [pre-installed](https://docs.python.org/3/library/sqlite3.html) with python, a "Batteries-Included" programming language.

One major caveat here is the login/register buttons; In textual, you can capture `click` messages from the parent app by overriding the `handle_button_pressed` method, which is a special handler to read messages sent by a child button. This function will help us create the necessary logic simulating the login and register screens concept.

## Views Vs Layouts <a name="ViewsLayouts"></a>

##### 🔝 [Go To TOC](#TOC). 

The other day, I was hopping around the source code, and I noticed that there are two ways to create a grid: Using the [`GridView`](https://github.com/Textualize/textual/blob/main/src/textual/views/_grid_view.py#L5) or the [`GridLayout`](https://github.com/Textualize/textual/blob/f702d1ac23a22c5143d825ea46795fbf8ccdb12b/src/textual/layouts/grid.py#L45) class. Apparently, a `GridView` is a layer of abstraction on top of `GridLayout` with an extra readable `grid` attribute. As a programmer, you can use either class to define a grid. But, if you want to read the `grid` value associated with a layout, you can use `GridView`. However, if you're going to use the `GridLayout` class, you can refer to [this example](https://github.com/Textualize/textual/blob/f702d1ac23a22c5143d825ea46795fbf8ccdb12b/src/textual/layouts/grid.py#L415). I think `GridView` is more flexible to use. It can interact with the parent application, unlike `GridLayout`.

With that noted, let's continue the implementation of our login form. In the next section, we will use sqlite3 as a database.

## Storing User Credentials <a name="StoringCredentials"></a>

##### 🔝 [Go To TOC](#TOC). 

In this section, we will learn how to build a little database to store the data submitted by a user. Having sqlite3 installed on our machine, we need to create a file called `db.py` and add the following code:

```python
import sqlite3
import contextlib


def create_users_table() -> None:
    create_table_query = """
        CREATE TABLE IF NOT EXISTS
            users(
                id integer primary key autoincrement,
                username VARCHAR UNIQUE not null,
                password VARCHAR not null
            )
    """
    # connect to the database
    # using contextlib to avoid connections issues with
    # sqlite when forget closing the connection and cursor
    with contextlib.closing(sqlite3.connect("./users.sqlite")) as connection:
        # create a crusor to interract with the database
        with contextlib.closing(connection.cursor()) as cursor:
            cursor.execute(create_table_query)
            # commit the changes
            connection.commit()
```

This code snippet creates a table called "users" that will hold each user's id, username, and password. You can extend this table to store whatever information you want, such as phone number, gender, etc. For demonstration purposes, let's stick with these data fields. In our function, notice the use of `contextlib`, which is a helpful built-in module to control the context of running code; it is usually used for synchronization. In our case, we used it to allow only one connection to the database to perform CRUD operations and close it afterward. From what I have experienced, this is the best practice to interact with the database if you are using SQLite.

Similarly, let's build our function(similar to an SQL procedure) to register a user.

```python
def register_user(username: str, password: str) -> bool:
    query = """
        INSERT INTO 
            users (
                username
                , password
            )
        VALUES (
                ?
                , ?
            )
    """
    try:
        with contextlib.closing(sqlite3.connect("./users.sqlite")) as connection:
            # create a crusor to interract with the database
            with contextlib.closing(connection.cursor()) as cursor:
                cursor.execute(query, (username, password))
                # commit the changes
                connection.commit()
        return True
    except:
        return False
```

Notice the use of the `?` symbol, which will control the values of the username and the password entered by a user. This common practice shields you against the well-known TOP 10 OWASP attacks. Notice also the use of a try-catch block to handle the case of a user registering twice. This function returns True if a user has registered successfully and False if the user already exists.

Bear in mind that, in a real-world application, you never store sensitive information inside a database; you store its hashes instead. But, for demonstration purposes, let's bypass this requirement.

Moving on, we need to create a function to check if a user exists in the database as a record.

```python
def check_user(username: str, password: str) -> str:
    result = ""
    select_query = """
        SELECT
        *
        FROM
            users
        WHERE
            username = ? 
        AND
            password = ?
    """
    with contextlib.closing(sqlite3.connect("./users.sqlite")) as connection:
        # create a crusor to interract with the database
        with contextlib.closing(connection.cursor()) as cursor:
            cursor.execute(select_query, (username, password))
            # commit the changes
            connection.commit()
            result = cursor.fetchone()
    return result
```

Take a look at the `result = cursor.fetchone()` statement, which will return a record(e.g., a tuple of id, username, and a password) if the user exists, None otherwise.

Up until now, we have utility scripts that help us interact with the database with a level of abstraction. Now, let's go back to our main application.

## Connecting The Database <a name="ConnectingDatabase"></a>

##### 🔝 [Go To TOC](#TOC). 

Now, let's add the necessary logic for our login form.

```python
class MainApp(App):
    username: Reactive[RenderableType] = Reactive("")
    password: Reactive[RenderableType] = Reactive("")

    def handle_button_pressed(self, message: ButtonPressed) -> None:
        """A message sent by the submit button"""
        assert isinstance(message.sender, Button)
        button_name = message.sender.name
        self.username = self.login_grid.username.content
        self.password = self.login_grid.password.content
        if button_name == "login":
            # Query username and password to check if exists


    async def on_mount(self) -> None:
        self.login_grid = LoginGrid()
        await self.view.dock(self.login_grid)
```

Let's begin with the edge cases. The first one is where a user enters an empty string in the username field and/or the password field. To address this case, we can add the following if statement:

```python
if len(self.username) == 0 or len(self.password) == 0:
```

Now, we need to display a nicely formatted message to prompt users to reenter a valid username and/or password. In Textual, there is no Label widget yet, but we can use a button for that purpose:


```python
# add new widget
await self.view.dock(
    Button(
        label="Please enter a valid username and password!",
        style="bold white on rgb(50,57,50)",
    )
) 
```

But first, we need to clear up the screen to draw this button on the terminal. To do so, we can use the `clear` function on the docks and widgets associated with the app.

```python
self.view.layout.docks.clear()
self.view.widgets.clear()
```

After adding these lines of code, our main app becomes:

```python
class MainApp(App):
    username: Reactive[RenderableType] = Reactive("")
    password: Reactive[RenderableType] = Reactive("")

    async def handle_button_pressed(self, message: ButtonPressed) -> None:
        """A message sent by the submit button"""
        assert isinstance(message.sender, Button)
        button_name = message.sender.name
        self.username = self.login_grid.username.content
        self.password = self.login_grid.password.content
        if button_name == "login":
            # clear widgets and docks
            self.view.layout.docks.clear()
            self.view.widgets.clear()
            if len(self.username) == 0 or len(self.password) == 0:
                # add new widget
                await self.view.dock(
                    Button(
                        label="Please enter a valid username and password!",
                        style="bold white on rgb(50,57,50)",
                    )
                )

    async def on_mount(self) -> None:
        self.login_grid = LoginGrid()
        await self.view.dock(self.login_grid)
```

Notice that our `handle_button_pressed` becomes asynchronous because of the `await self.view.dock` statements. Now, we need to display this message for a couple of seconds before redrawing back the widgets to prompt the user to enter a new username and password:

```python
await asyncio.sleep(2)
# clear widgets
self.view.layout.docks.clear()
self.view.widgets.clear()
# redraw back the grid
await self.view.dock(self.login_grid)
```

If our program didn't hit this case, it means the user has entered both username and password. Now, we need to check whether or not the user exists in our database. To do so, we can add the following if-else statements:

```python
from db import check_user

class MainApp(App):
    username: Reactive[RenderableType] = Reactive("")
    password: Reactive[RenderableType] = Reactive("")

    async def handle_button_pressed(self, message: ButtonPressed) -> None:
        """A message sent by the submit button"""
        assert isinstance(message.sender, Button)
        button_name = message.sender.name
        self.username = self.login_grid.username.content
        self.password = self.login_grid.password.content
        if button_name == "login":
            # clear widgets and docks
            self.view.layout.docks.clear()
            self.view.widgets.clear()
            if len(self.username) == 0 or len(self.password) == 0:
                # add new widget
                await self.view.dock(
                    Button(
                        label="Please enter a valid username and password!",
                        style="bold white on rgb(50,57,50)",
                    )
                )
            elif check_user(self.username, self.password):
                # clear widgets
                self.view.layout.docks.clear()
                self.view.widgets.clear()
                # add new widget
                await self.view.dock(
                    Button(
                        label=f"Weclome back {self.username}!",
                        style="bold white on rgb(50,57,50)",
                    )
                )
            else:
                # clear widgets
                self.view.layout.docks.clear()
                self.view.widgets.clear()
                # add new widget
                await self.view.dock(
                    Button(
                        label="Invalid Credentials!",
                        style="bold white on rgb(50,57,50)",
                    )
                )
                await asyncio.sleep(2)
                # clear widgets
                self.view.layout.docks.clear()
                self.view.widgets.clear()
                # redraw back the grid
                await self.view.dock(self.login_grid)
```

Alternatively, we can implement our register form:

```python
        elif button_name == "register":
                result = None
                self.view.layout.docks.clear()
                self.view.widgets.clear()
                if len(self.username) == 0 or len(self.password) == 0:
                    # add new widget
                    await self.view.dock(
                        Button(
                            label="Please enter a valid username and password!",
                            style="bold white on rgb(50,57,50)",
                        )
                    )
                    await asyncio.sleep(2)
                    # clear widgets
                    self.view.layout.docks.clear()
                    self.view.widgets.clear()
                    # redraw back the grid
                    await self.view.dock(self.login_grid)
                else:
                    result = register_user(self.username, self.password)
                if result:
                    # add new widget
                    await self.view.dock(
                        Button(
                            label="User Registered Successfully!",
                            style="bold white on rgb(50,57,50)",
                        )
                    )
                    await asyncio.sleep(2)
                    # clear widgets
                    self.view.layout.docks.clear()
                    self.view.widgets.clear()
                    # redraw back the grid
                    await self.view.dock(self.login_grid)
                elif not result and len(self.username) > 0:
                    # add new widget
                    await self.view.dock(
                        Button(
                            label="Username Already Exists!",
                            style="bold white on rgb(50,57,50)",
                        )
                    )
                    await asyncio.sleep(2)
                    # clear widgets
                    self.view.layout.docks.clear()
                    self.view.widgets.clear()
                    # redraw back the grid
                    await self.view.dock(self.login_grid)
```

## Putting It All Together <a name="PuttingTogether"></a>

##### 🔝 [Go To TOC](#TOC). 

The workflow of our program is the following after running `python login.py`:

* The login screen opens up.
* Type in your user and password.
* Click on register to add a new user to the database.
* The application will display the text:
  * "Please enter a valid username and password!" if one of the fields is empty
  * "User Registered Successfully!" for a new user.
  * "Username Already Exists!" for registered user.
* Click on login to login into the app.
* The application will display the text:
  * "Weclome back username!" if the user has registered to the application.
  * "Invalid Credentials!" otherwise.

The complete listing for our application looks like the following:

```python
import asyncio

from rich.align import Align
from rich.box import DOUBLE
from rich.console import RenderableType
from rich.panel import Panel
from rich.style import Style
from rich.text import Text
from textual import events
from textual.app import App
from textual.reactive import Reactive
from textual.views import GridView
from textual.widget import Widget
from textual.widgets import Button, ButtonPressed

from db import check_user, create_users_table, register_user


class InputText(Widget):

    title: Reactive[RenderableType] = Reactive("")
    content: Reactive[RenderableType] = Reactive("")
    mouse_over: Reactive[RenderableType] = Reactive(False)

    def __init__(self, title: str):
        super().__init__(title)
        self.title = title

    def on_enter(self) -> None:
        self.mouse_over = True

    def on_leave(self) -> None:
        self.mouse_over = False

    def on_key(self, event: events.Key) -> None:
        if self.mouse_over == True:
            if event.key == "ctrl+h":
                self.content = self.content[:-1]
            else:
                self.content += event.key

    def validate_title(self, value) -> None:
        try:
            return value.lower()
        except (AttributeError, TypeError):
            raise AssertionError("title attribute should be a string.")

    def render(self) -> RenderableType:
        renderable = None
        if self.title.lower() == "password":
            renderable = "".join(map(lambda char: "*", self.content))
        else:
            renderable = Align.left(Text(self.content, style="bold"))
        return Panel(
            renderable,
            title="",
            title_align="center",
            height=3,
            style="bold white on rgb(50,57,50)",
            border_style=Style(color="green"),
            box=DOUBLE,
        )


class LoginGrid(GridView):
    username: Reactive[RenderableType] = Reactive("")
    password: Reactive[RenderableType] = Reactive("")

    async def on_mount(self) -> None:
        # define input fields
        self.username = InputText("username")
        self.password = InputText("password")
        self.grid.set_align("center", "center")
        self.grid.set_gap(1, 1)
        # Create rows / columns / areas
        self.grid.add_column("column", repeat=2, size=40)
        self.grid.add_row("row", repeat=3, size=3)
        # Place out widgets in to the layout
        button_style = "bold red on white"
        label_style = "bold white on rgb(60,60,60)"
        username_label = Button(
            label="username", name="username_label", style=label_style
        )
        password_label = Button(
            label="password", name="password_label", style=label_style
        )
        self.grid.add_widget(username_label)
        self.grid.add_widget(self.username)
        self.grid.add_widget(password_label)
        self.grid.add_widget(self.password)
        self.grid.add_widget(
            Button(label="register", name="register", style=button_style)
        )
        self.grid.add_widget(Button(label="login", name="login", style=button_style))


class MainApp(App):
    username: Reactive[RenderableType] = Reactive("")
    password: Reactive[RenderableType] = Reactive("")

    async def handle_button_pressed(self, message: ButtonPressed) -> None:
        """A message sent by the submit button"""
        assert isinstance(message.sender, Button)
        button_name = message.sender.name
        self.username = self.login_grid.username.content
        self.password = self.login_grid.password.content
        if button_name == "login":
            # clear widgets
            self.view.layout.docks.clear()
            self.view.widgets.clear()
            if len(self.username) == 0 or len(self.password) == 0:
                # add new widget
                await self.view.dock(
                    Button(
                        label="Please enter a valid username and password!",
                        style="bold white on rgb(50,57,50)",
                    )
                )
                await asyncio.sleep(2)
                # clear widgets
                self.view.layout.docks.clear()
                self.view.widgets.clear()
                # redraw back the grid
                await self.view.dock(self.login_grid)
            elif check_user(self.username, self.password):
                # clear widgets
                self.view.layout.docks.clear()
                self.view.widgets.clear()
                # add new widget
                await self.view.dock(
                    Button(
                        label=f"Weclome back {self.username}!",
                        style="bold white on rgb(50,57,50)",
                    )
                )
            else:
                # clear widgets
                self.view.layout.docks.clear()
                self.view.widgets.clear()
                # add new widget
                await self.view.dock(
                    Button(
                        label="Invalid Credentials!",
                        style="bold white on rgb(50,57,50)",
                    )
                )
                await asyncio.sleep(2)
                # clear widgets
                self.view.layout.docks.clear()
                self.view.widgets.clear()
                # redraw back the grid
                await self.view.dock(self.login_grid)
        elif button_name == "register":
            result = None
            self.view.layout.docks.clear()
            self.view.widgets.clear()
            if len(self.username) == 0 or len(self.password) == 0:
                # add new widget
                await self.view.dock(
                    Button(
                        label="Please enter a valid username and password!",
                        style="bold white on rgb(50,57,50)",
                    )
                )
                await asyncio.sleep(2)
                # clear widgets
                self.view.layout.docks.clear()
                self.view.widgets.clear()
                # redraw back the grid
                await self.view.dock(self.login_grid)
            else:
                result = register_user(self.username, self.password)
            if result:
                # add new widget
                await self.view.dock(
                    Button(
                        label="User Registered Successfully!",
                        style="bold white on rgb(50,57,50)",
                    )
                )
                await asyncio.sleep(2)
                # clear widgets
                self.view.layout.docks.clear()
                self.view.widgets.clear()
                # redraw back the grid
                await self.view.dock(self.login_grid)
            elif not result and len(self.username) > 0:
                # add new widget
                await self.view.dock(
                    Button(
                        label="Username Already Exists!",
                        style="bold white on rgb(50,57,50)",
                    )
                )
                await asyncio.sleep(2)
                # clear widgets
                self.view.layout.docks.clear()
                self.view.widgets.clear()
                # redraw back the grid
                await self.view.dock(self.login_grid)

    async def on_mount(self) -> None:
        create_users_table()
        self.login_grid = LoginGrid()
        await self.view.dock(self.login_grid)


if __name__ == "__main__":
    MainApp.run(log="textual.log")
```

## Wrapping up <a name="WrappingUp"></a>

##### 🔝 [Go To TOC](#TOC). 

A view is one of the essential textual components that instructs the child components or widgets to render in the available space on the terminal. For example, as we discussed, a Grid View arranges child components by a combination of rows and columns.

And this constitutes the Login app walkthrough. The resulting application can actually register a new user and login into the application.

As always, this article is a gift to you from a higher-dimensional entity. You can share it with whomever you like or use it in any way that would be beneficial to your personal and professional development. By supporting this blog, you keep me motivated to publish high-quality content related to python in general and textual specifically. Thank you in advance for your ultimate support!

You are free to use the code in this article, which is licensed under [the MIT license](https://github.com/Harmouch101/Textual-Experimentations), as a starting point for various needs. Don’t forget to look at [the readme file](https://github.com/Textualize/textual) and use your imagination to make more complex apps meaningful to your use case.

## Future Work <a name="FutureWork"></a>

##### 🔝 [Go To TOC](#TOC). 

Now that you have created a fully functional login/register screen in textual, which worked as intended, you can make a chat room that uses these forms.

Keep in mind that this task is somewhat a medium level. It is objectively not easy to implement such applications. But, Textual provides us with a great toolkit on the user interface side of things, facilitating the ease of creating fully-featured, blazingly fast rendered widgets.

If you get stuck, it is not that big of a deal because nothing works immediately as you implement it; Sometimes, you will go through trial and error, which is so common in the fascinating programming world. Try to focus on one task at a time, and you will be surprised by your capabilities.

There is so much to explore about the fantastic world of Textal, and UI designers that are knowledgeable in this domain are few and highly valued. Remember that it will certainly pay off to dig into such topics about TUI at some point.

Happy Coding, folks; see you in the next one.