Adventures in Machine Learning

Streamlining Configuration Data with TOML in Python Applications

Introduction to TOML as a Configuration File Format

Every software program or application requires some form of settings or configuration data to function correctly. In the early days of computing, developers hardcoded these settings directly into the code, making them difficult to change without modifying the underlying program’s code.

With the rise of configuration files, however, developers have found a more efficient way of handling settings and customizations. TOML, or Tom’s Obvious Minimal Language, is a configuration file format that has gained widespread acceptance among developers.

It is an easy-to-read format that allows developers to separate application code from settings and configurations. In this article, we’ll explore the syntax of TOML documents and how developers use them to store and manage configuration data.

Advantages of Using Configuration Files

Configuration files offer a number of advantages over hardcoded settings in program code. One of the most significant benefits is that configuration files allow developers to separate code and configuration data.

This separation increases the flexibility and maintainability of the code. Developers can modify the configuration settings without having to modify the code.

This separation makes it easier to test and debug applications, ensuring that bugs in the configuration data do not affect the application itself. Using a configuration file also simplifies the process of deploying an application.

Developers can create a set of configurations that are appropriate for different deployment settings or environments. Instead of having to modify the code to suit each deployment, they can include the relevant configuration file, and the application will read the appropriate settings from the file.

TOML Syntax and Key-Value Pairs

The structure of TOML documents is crucial for understanding how developers use it to store and manage configuration data. TOML documents consist of key-value pairs, with the keys representing the names of the settings, and the values containing the corresponding data.

Every key-value pair has a key and a value that are separated by an equal sign.

The keys in TOML documents define the settings or configuration parameter names.

A key can be a simple string or a combination of multiple strings separated by periods. In TOML, these are called “dotted keys,” and they allow for nested grouping of keys.

These keys are typically used to group related settings or provide a hierarchy of configuration values. Values in TOML can contain various data types, including strings, numbers, Booleans, and arrays.

The data type is determined automatically by parsing the value from the text, but data types can also be indicated using specific syntax. Let’s explore some of the common data types used in TOML.

Strings, Numbers, and Booleans in TOML

Strings in TOML are text data enclosed in either single or double quotation marks. This use of quotation marks is similar to that in most programming languages.

However, one significant difference is that TOML supports multi-line strings, which consist of multiple lines of text enclosed within three quotation marks. This feature allows developers to store lengthy pieces of text, such as user feedback or license agreements.

TOML supports numbers, which can be either integers or floating-point values. You can represent numbers in TOML in the same way as in programming languages.

Numbers need no quotation marks. However, some syntax of TOML exists that indicates the type of a number explicitly.

For example, you can use “0b” for binary, “0x” for hexadecimal, or specify a value using scientific notation like 1.2

3e4. Finally, Booleans in TOML are either “true” or “false.” These data types are useful for settings that have only two possible states, such as enabling or disabling a feature of your program.


TOML syntax relies on key-value pairs, and it’s easy to understand. Keys determine the configuration parameter names, with special cases of dotted keys used in groupings.

Values, on the other hand, define the data and can be of different data types, including string, number, and Boolean. While configurations in programs may seem insignificant, the proper use of configuration files and TOML improves program maintenance, flexibility, and deployment.

Therefore, having a sound understanding of TOML’s syntax is essential for effective software development.

TOML Schema Validation

A schema is a set of rules that define how data should be structured. In configuration files like TOML, the schema specifies the mandatory and optional fields, data types, and their default values.

A schema guarantees that users include all the necessary fields, formats the proper data types, and flags validation errors when users supply invalid data. This article examines the schema requirements in TOML files, the lack of schema language in TOML, and some tools for schema validation.

Schema Requirements in Configuration Files

TOML configurations must have some mandatory fields. Consider a database configuration file for a Django project.

The file may have the following required fields: database name, database user, database host, and database password. Without these fields, the Django database driver will not function correctly.

It is not uncommon to find other mandatory fields in other configuration files, such as port numbers, file paths, and domain names. Other configuration files have optional fields.

An optional field may have a default value that the application should use in case the user doesn’t provide a value. For example, users may include an optional flag to turn on or off a feature in the application.

The default value should be set to false if it’s turned off and true if it’s turned on.

Lack of Schema Language in TOML

Unlike JSON and YAML, TOML doesn’t have a schema language that developers can use to define schema rules. In YAML, for example, developers can define schema rules using the JSON schema standard.

The JSON schema is a JSON object that defines validation rules for JSON data. However, TOML does not have a similar standard.

As a result, developers have proposed several approaches to defining schema rules in TOML. Some approaches use extended TOML syntax or a separate syntax altogether.

In essence, these approaches rely on custom libraries to parse the schema rules and validate TOML data. In practice, this leads to more dependencies and more complicated code.

Tools for Schema Validation in TOML

One popular Python library for TOML schema validation is pydantic. Pydantic is an open-source library that relies on type hints and data validation declarations to validate TOML data.

Pydantic checks that the TOML contains all the mandatory fields, applies the right data type conversion, and throws validation errors when it encounters forbidden values. Pydantic also supports default values, custom data type validations, JSON Schema v4 compatibility, and more.

The following is an example of using Pydantic:


from pydantic import BaseModel

class DatabaseSettings(BaseModel):

database_name: str

database_user: str

database_host: str

database_pass: str

class Config:

orm_mode = True

database_settings = DatabaseSettings.parse_file(“database.toml”)

# Validate configuration data


Another Python library for TOML schema validation is Taplo. Like Pydantic, Taplo relies on a separate schema definition file to validate TOML configurations.

However, Taplo uses JSON Schema to validate the Toml. Taplo caches the required schema files locally, meaning it can be used offline.

Besides TOML support, Taplo also supports multiple schema and format validation, custom CLI, and more. Below is an example:


from taplo import loader, linter

doc = loader.load_file(“my_configuration.toml”)

# Validate



Working with TOML in Python

Python has several libraries that ease working with TOML. Parsing TOML data in Python is straightforward.

The built-in library, Toml, and Tomli are popular libraries for parsing TOML text. Toml is a standard library that users can import and use out of the box.

Tomli, on the other hand, is a third-party lightweight library that supports parsing of TOML files. The libraries return Python objects that users can use in their programs.

Comparing TOML Types and Python Types

TOML data types and their respective Python types are usually straightforward for users to understand. A TOML string type has the same semantics as Python strings, while TOML integers and floats are equivalent to Python integers and floats.

Python’s built-in Boolean type is also equivalent to TOML Boolean. TOML arrays map to Python lists, while tables map to dictionaries.

It’s essential to ensure that the types are consistent between TOML and Python for your program to work correctly. The TOML spec defines how the types map to the corresponding Python types.

Using Configuration Files in Python Projects

Developers use configuration files in Python projects in various ways. One common way is to import the configuration data as Python objects into their programs.

This way, they can use TOML configurations alongside the main Python code. Configuration files are usually stored in the root directory of a project or in a subdirectory.

Users can then configure the file path in the configuration or pass it in as an environment variable.

Writing TOML Documents with Tomli_w

Tomli_w is a lightweight Python library used to write TOML documents. The library provides an easy-to-use API to create TOML documents from Python data structures.

Tomli_w is simple and doesn’t require any encoding or decoding. “`python

import toml

from tomli_w import toml_writer

doc = {

“some_key”: {

“nested_key”: “some_value”


“some_other_key”: [1, 2,



toml_str = toml_writer.dumps(doc)



The code above generates the TOML document string:



nested_key = “some_value”

some_other_key = [







TOML schema validation provides a way for users to supply correct configurations, avoiding crashes and errors in their applications. Additionally, there are various Python libraries, such as Pydantic, that users can use to validate TOML data.

Developers can use TOML configurations in Python applications by parsing, using the data, and writing configuration files to disk using Python libraries like Toml and Tomli_W. TOML’s Role in the Python Ecosystem

TOML is a configuration file format that has gained popularity among Python developers because of its simplicity, readability, and maintainability.

TOML has several uses in the Python ecosystem, ranging from application configurations to data serialization and persistence. Below are some of the use cases where TOML shines in the Python ecosystem.

Application Configurations

Many Python applications require some form of configuration data to function correctly. Examples of configuration data include database connections, server settings, and environment variables.

TOML provides an excellent format for storing this configuration data. TOML decreases maintenance time and simplifies debugging, as developers can modify configuration data without modifying the code.

Furthermore, developers can use Python libraries like Pydantic to validate configuration data and prevent application crashes.

Data Serialization and Persistence

Python data structures like lists, dictionaries, and tuples can be serialized and persisted in TOML format. The serialization process involves encoding of the data structures into a TOML string that can be saved to a disk or transmitted over the network.

Python libraries like TOMLkit and TOMLencoder simplify the serialization process and allow users to convert Python objects into TOML strings. On the other hand, the persistence process involves retrieval of data stored in TOML format back into Python objects.

Python libraries like TOML and TOMliW ease the persistence process, allowing users to load TOML strings back into Python data structures.

Configuration Management in Microservices

In the world of microservices and distributed systems, configuration management is critical. It’s essential to have a way to manage configuration data for different services and environments.

TOML provides an excellent format for managing configurations in microservices. Developers can create separate TOML files for each microservice, storing the configurations relevant to that service.

Furthermore, they can set environment-specific configurations using environment variables and include these variables in the TOML files. As such, the microservices can work seamlessly across different environments.

Limitations and Use Cases for TOML

Although TOML has several benefits in the Python ecosystem, it has some limitations and use cases. Understanding these limitations helps developers make informed decisions in using TOML in their projects.

Limited Data Type Support

TOML supports a limited range of data types, including strings, integers, floats, Booleans, arrays, and tables. It lacks support for advanced data types like complex numbers, sets, and tuples.

Developers who require these data types may have to use alternative formats like JSON or YAML.

Not Suitable for Large Data Sets

TOML is ideal for small or mid-sized data sets. Large data sets may result in larger TOML files, and the TOML parser may take more time to parse the data.

Alternatively, developers may have to split large data sets into separate files, which increase complexity and maintenance time.

Highly Structured Data

TOML is best suited for highly structured data. It has a key-value structure that requires key-value pairs to maintain consistency in the data.

Developers who require a format that supports irregular data structures may have to consider alternative formats. In conclusion, TOML has played an increasingly significant role in the Python ecosystem for configuration data management alongside other popular formats like JSON and YAML.

Understanding its use cases and limitations will help developers make informed decisions about utilizing the format in their projects. TOML is a configuration file format that enables developers to store and manage configuration data outside their program’s code.

It provides a structured way of defining settings and customizations while allowing for flexibility and maintainability. The article covered how TOML works and its syntax, including key-value pairs and the data types supported.

It also looked at ways developers can validate TOML configurations, parse and write TOML documents, and use the format in Python projects. While TOML has benefits such as readability, simplicity, and ease of use, it also has limitations.

Nonetheless, understanding these limitations and considering use cases can help developers make informed choices about when to use TOML. Overall, TOML is an important tool in the Python ecosystem, improving application maintainability and flexibility, and developers should consider using it for their configuration management needs.

Popular Posts