PyYAML (How It Works For Developers)

Introduction

PyYAML is a Python library that works as a YAML parser and emitter. YAML (YAML Ain’t Markup Language), is a human-readable data serialization format that integrates well with Python applications, features great error support, capable extension API, and more. YAML is often used for configuration files and data exchange between languages with different data structures, with human readability in mind. Later in this article we will look into IronPDF, a PDF-generation Python package from IronSoftware.

Key Features of PyYAML

1. Human-Readable Format: YAML is designed to be easy to read and write, making it ideal for complex configuration files and data serialization.
2. Full YAML 1.1 Support: PyYAML supports the complete YAML 1.1 specification, including Unicode support and custom data types.
3. Integration with Python: PyYAML provides Python-specific tags that allow for the representation of arbitrary Python objects, making it versatile for various applications.
4. Error Handling: PyYAML offers sensible error messages, which can be very helpful during debugging.

Installation

To install the YAML package, you can use pip:

pip install pyyaml

Basic Usage

Here is a simple example of how to use PyYAML to load and dump a YAML document to and from an arbitrary Python object.

import yaml
# Sample YAML data
yaml_data = """
name: John Doe
age: 30
children:
  - name: Jane Doe
    age: 10
  - name: Jim Doe
    age: 8
"""
# Load YAML data
data = yaml.safe_load(yaml_data)
print(data)
# Dump Python data to YAML
yaml_output = yaml.dump(data, default_flow_style=False)
print(yaml_output)

import yaml
# Sample YAML data
yaml_data = """
name: John Doe
age: 30
children:
  - name: Jane Doe
    age: 10
  - name: Jim Doe
    age: 8
"""
# Load YAML data
data = yaml.safe_load(yaml_data)
print(data)
# Dump Python data to YAML
yaml_output = yaml.dump(data, default_flow_style=False)
print(yaml_output)

Output

Advanced Features

1. Custom Data Types: PyYAML allows you to define custom constructors and representors for handling complex data types for canonical YAML format.

import yaml
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
def person_representer(dumper, data):
    return dumper.represent_mapping('!Person', {'name': data.name, 'age': data.age})
def person_constructor(loader, node):
    values = loader.construct_mapping(node)
    return Person(**values)
yaml.add_representer(Person, person_representer)
yaml.add_constructor('!Person', person_constructor)
# Object Serialization
person = Person(name='John Doe', age=30)
yaml_data = yaml.dump(person)
print(yaml_data)
# Deserialize YAML to a Person object
loaded_person = yaml.load(yaml_data, Loader=yaml.FullLoader)
print(loaded_person.name, loaded_person.age)

import yaml
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
def person_representer(dumper, data):
    return dumper.represent_mapping('!Person', {'name': data.name, 'age': data.age})
def person_constructor(loader, node):
    values = loader.construct_mapping(node)
    return Person(**values)
yaml.add_representer(Person, person_representer)
yaml.add_constructor('!Person', person_constructor)
# Object Serialization
person = Person(name='John Doe', age=30)
yaml_data = yaml.dump(person)
print(yaml_data)
# Deserialize YAML to a Person object
loaded_person = yaml.load(yaml_data, Loader=yaml.FullLoader)
print(loaded_person.name, loaded_person.age)

Output

1. Handling Large Files: PyYAML can handle multiple yaml documents or large YAML files efficiently by using stream-based loading and dumping.

import yaml
# Load a large YAML file
with open('large_file.yaml', 'r') as file:
    data = yaml.safe_load(file)
# Dump data to a large YAML file
with open('output_file.yaml', 'w') as file:
    yaml.dump(data, file)

import yaml
# Load a large YAML file
with open('large_file.yaml', 'r') as file:
    data = yaml.safe_load(file)
# Dump data to a large YAML file
with open('output_file.yaml', 'w') as file:
    yaml.dump(data, file)

Output

Introducing IronPDF

IronPDF is a powerful Python library designed to create, edit, and sign PDFs using HTML, CSS, images, and JavaScript. It offers commercial-grade performance with a low memory footprint. Key features include:

HTML to PDF Conversion

Convert HTML files, HTML strings, and URLs to PDFs. For example, render a webpage as a PDF using the Chrome PDF renderer.

Cross-Platform Support

Compatible with various .NET platforms, including .NET Core, .NET Standard, and .NET Framework. It supports Windows, Linux, and macOS.

Editing and Signing

Set properties, add security with passwords and permissions, and apply digital signatures to your PDFs.

Page Templates and Settings

Customize PDFs with headers, footers, page numbers, and adjustable margins. IronPDF supports responsive layouts and custom paper sizes.

Standards Compliance

IronPDF adheres to PDF standards such as PDF/A and PDF/UA. It supports UTF-8 character encoding and handles assets like images, CSS, and fonts.

Generate PDF Documents using IronPDF and PyYaml

import yaml
import json
from ironpdf import * 
# Apply your license key
License.LicenseKey = "your license"
# Sample YAML data with standard yaml tags
yaml_data = """
name: IronPDF User1
age: 25
children:
  - name: IronPDF User2
    age: 23
  - name: IronPDF User3
    age: 24
"""
# Load YAML data to only basic python objects
data = yaml.safe_load(yaml_data)
print(data)
# Dump Python data to YAML
yaml_output = yaml.dump(data, default_flow_style=False)
print(yaml_output)
# Write YAML to File 
with open('output_file.yaml', 'w') as file:
    yaml.dump(yaml_output, file)
# Write YAML as JSON
with open('output_file.json', 'w') as json_file:
    json.dump(yaml_output, json_file)
# Read Json and Indent
output = json.dumps(json.load(open('output_file.json')), indent=2)
print(output)
# create Renderer
renderer = ChromePdfRenderer()
# Create a PDF from a HTML string using Python
content = "<h1>Awesome Iron PDF with PYYML</h1>"
content += "<p>YAML data: "+ yaml_data +"</p>"
pdf = renderer.RenderHtmlAsPdf(content)    
    # Export to a file or Stream
pdf.SaveAs("awesome.pdf")

import yaml
import json
from ironpdf import * 
# Apply your license key
License.LicenseKey = "your license"
# Sample YAML data with standard yaml tags
yaml_data = """
name: IronPDF User1
age: 25
children:
  - name: IronPDF User2
    age: 23
  - name: IronPDF User3
    age: 24
"""
# Load YAML data to only basic python objects
data = yaml.safe_load(yaml_data)
print(data)
# Dump Python data to YAML
yaml_output = yaml.dump(data, default_flow_style=False)
print(yaml_output)
# Write YAML to File 
with open('output_file.yaml', 'w') as file:
    yaml.dump(yaml_output, file)
# Write YAML as JSON
with open('output_file.json', 'w') as json_file:
    json.dump(yaml_output, json_file)
# Read Json and Indent
output = json.dumps(json.load(open('output_file.json')), indent=2)
print(output)
# create Renderer
renderer = ChromePdfRenderer()
# Create a PDF from a HTML string using Python
content = "<h1>Awesome Iron PDF with PYYML</h1>"
content += "<p>YAML data: "+ yaml_data +"</p>"
pdf = renderer.RenderHtmlAsPdf(content)    
    # Export to a file or Stream
pdf.SaveAs("awesome.pdf")

Code Explanation

1. Imports:

   • The script begins by importing the necessary Python libraries and modules: yaml, json, and ironpdf. These libraries are used for handling YAML and JSON data formats, as well as for PDF generation using IronPDF.

2. Setting License Key:

   • There's a step to set a license key (License.LicenseKey = "your license") for IronPDF. This is crucial for using the IronPDF library legally and effectively.

3. Sample YAML Data:

   • Defines a sample YAML-formatted string (yaml_data) that contains information about a hypothetical person and their children. This data serves as an example to demonstrate YAML processing.

4. YAML Operations:

   • The script loads the YAML data using yaml.safe_load() to convert it into Python data structures. This allows the script to manipulate and work with the data programmatically.

5. Dumping to YAML:

   • Converts Python data structures back into YAML format using yaml.dump(). This demonstrates how to serialize Python objects into YAML format for storage or transmission.

6. Writing to Files:

   • Writes the YAML data to a file (output_file.yaml) using yaml.dump(). Similarly, it converts YAML data into JSON format and writes it to another file (output_file.json) using json.dump().

7. Reading JSON and Formatting:

   • This operation reads the JSON data from output_file.json, parses it, and formats it with an indentation of 2 spaces using json.dumps(). This operation illustrates how to read and format JSON data for better readability or further processing.

8. Generating PDF with IronPDF:

   • Utilizes IronPDF (ChromePdfRenderer()) to render an HTML content string into a PDF document. The HTML content includes the original YAML data embedded within it as part of the document content.

9. Saving PDF:

   • This final step saves the generated PDF document (awesome.pdf) to the filesystem using pdf.SaveAs(). It demonstrates how to create and save PDF documents programmatically.

Output

PDF

IronPDF License

IronPDF runs on the license key for Python. IronPDF for Python offers a free trial license key to allow users to check out its extensive features before purchase.

Place the License Key at the start of the script before using IronPDF package:

from ironpdf import * 
# Apply your license key
License.LicenseKey = "key"

from ironpdf import * 
# Apply your license key
License.LicenseKey = "key"

Conclusion

PyYAML is a powerful and flexible library for working with YAML in Python. Its human-readable format, full YAML 1.1 support, and integration with Python make it an excellent choice for configuration files, data serialization, and more. Whether you are dealing with simple configurations or complex data structures, PyYAML provides the tools you need to handle YAML data effectively.

IronPDF is a Python package that facilitates the conversion of HTML content into PDF documents. It offers a straightforward API (ChromePdfRenderer) for developers to generate high-quality PDFs from HTML, including support for modern web standards like CSS and JavaScript. This makes it an effective tool for dynamically creating and saving PDF documents directly from Python applications.