API Interaction with the Requests Library | Python for DevOps: The Ultimate Hands-On Guide

Book Overview & Buying
Table Of Contents

Python for DevOps: The Ultimate Hands-On Guide

By : LM Academy

Buy this Video

Python for DevOps: The Ultimate Hands-On Guide

By: LM Academy

Buy this Video

Overview of this book

This course starts by guiding learners through setting up a Python environment tailored for DevOps tasks, covering version management, virtual environments, and interactive coding with JupyterLab. Students build a strong foundation in Python, including variables, loops, functions, data structures, and object-oriented programming, with practical DevOps exercises like disk usage calculation and log management. As the course progresses, learners dive into advanced Python features for DevOps, such as generators, decorators, exception handling, resource management, and logging practices. They gain hands-on experience with APIs, file handling, parsing JSON/YAML/CSV data, automating operations, and securely managing environment variables. The final sections focus on professional-grade development practices, including static typing, automated testing with Pytest, project structuring, and CI/CD pipeline creation. Students design command-line interfaces, integrate GitHub Actions workflows, implement linting and security checks, and automate deployment to PyPI. By the end, learners will be ready to solve complex DevOps challenges using Python, creating scalable, efficient, and automated solutions for modern infrastructures.

Getting Started on Your Python for DevOps Journey

Welcome and Course Overview

Maximizing Your Learning Experience

Setting Expectations for Our Journey

Python Environment Setup

Section Introduction

The Role of Python in Modern DevOps

Python Installation and Configuration Guide

Using pyenv to Manage Python Versions

Understanding Python Virtual Environments

Your First Steps with Virtual Environments

Strategies for Managing Multiple Virtual Environments

Exploring the Python REPL (Read-Eval-Print Loop)

From Script to Execution: Running Python Files

Interactive Coding with JupyterLab

Mastering Core Python Concepts

Section Introduction

Working with Variables

The Importance of Code Comments

Handling Numerical Data

Manipulating Strings

Practical Application: Calculating Disk Usage

Getting Started with Lists

Techniques for Modifying Lists

Practical Exercises with Lists

Understanding Tuples

An Introduction to Sets

Performing Set Operations

Practical Exercises with Sets

Comparing Lists, Tuples, and Sets

Getting Started with Dictionaries

Performing Dictionary Operations

Practical Exercises with Dictionaries

Fundamentals of Conditional Logic

Using If, Elif, and Else

Implementing Guard Clauses for Cleaner Code

Mastering For and While Loops

Controlling Loops with Break and Continue

An Introduction to List Comprehension

Advanced Comprehensions: Lists, Sets, Dictionaries

Fundamentals of Python Functions

Creating and Returning Values from Functions

Understanding Parameters and Arguments

Writing Effective Docstrings

Practical Exercises with Functions

Generating Sequences with the Range Function

Iterating with Enumerate and ZIP

Fundamentals of Object-Oriented Programming

Defining and Using Class Methods

Implementing Inheritance

Understanding *args and **kwargs

Argument Order with *args and **kwargs

Using *args and **kwargs in Function Calls

An Introduction to Lambda Functions

Using Lambda for Sorting Collections

Using Lambda for Transforming Collections

Using Lambda for Filtering Collections

Advanced Python: Generators and Decorators

Section Introduction

Understanding the Iteration Protocol

Iterators and Iterables in Practice

The Basics of Generator Syntax

Harnessing the Power of the yield Statement

Controlling Generator Execution: Pause and Resume

Managing State within Generators

Understanding Generator Exhaustion

Comparing return and yield

Practical Exercises with Generators

Creating Efficient Data Pipelines

Exploring Functions as First-Class Citizens

Implementing Factory Functions

Using Functions within Data Structures

An Introduction to Decorators

Passing Arguments to Decorators

Managing Return Values in Decorators

Exception Handling within Decorators

Preserving Function Metadata with functools.wraps

Applying Multiple Decorators

Error Handling and Resource Management

Section Introduction

Mastering Exception Syntax

A Paradigm Shift: Thinking in Exceptions

A Tour of Built-in Exceptions

Handling OS and Key Errors

Dealing with Index, Value, and Type Errors

Managing Attribute and Import Errors

Using the raise Statement Effectively

Best Practices for Raising Exceptions

Creating Your Own Custom Exceptions

Enriching Custom Exceptions with Context

The Imperative of Manual Resource Cleanup

Understanding the Context Manager Protocol

Simplifying Resource Management with with

Building Custom Context Managers

Using the contextmanager Decorator

Effective Logging in Python

Section Introduction

The Critical Role of Logging in DevOps

Deconstructing the Anatomy of a Log

Practical Application of Logging Principles

Understanding and Using Log Levels

Directing Logs to Files with File Handlers

Implementing Size-Based Log Rotation

Implementing Time-Based Log Rotation

Adopting Structured Logging with JSON

Enhancing Structured Logs with Custom Fields and Exception Info

Configuring Logging via INI Files

Dictionary-Based Logging Configuration

JSON-Based Logging Configuration

Implementing Dynamic Logging Configurations

Data Handling: Files, Regex, and Serialization

Section Introduction

Modern File System Paths with pathlib

Core File and Directory Operations

A Deep Dive into File I/O Modes

A Deep Dive into File Read/Write Methods

Getting Started with Regular Expressions

Mastering Quantifiers and Search Greediness

Using Capturing Groups in Regex

Understanding Non-Capturing Groups

Leveraging Back-references in Patterns

Finding All Matches with findall() and finditer()

Splitting Strings with Regex

Substituting Text with Regex

Parsing Data with JSON Deserialization

Generating Data with JSON Serialization

An Overview of YAML Data Handling

YAML Serialization and Deserialization Techniques

Techniques for Reading CSV Files

Techniques for Writing CSV Files

Automating DevOps Tasks and System Interactions

Section Introduction

Reading Environment Variables

Modifying and Unsetting Environment Variables

Managing Configuration with Dotenv Files

Programmatically Listing Directory Contents

Creating Directories with Python

Safely Deleting Files and Directories

Copying Files and Directory Trees

Moving and Renaming Files and Directories

Working with Temporary Files

Managing Temporary Directories

Executing External Commands with Subprocesses

Robust Error Handling for Subprocesses

Managing Subprocess Timeouts

API Interaction with the Requests Library

Section Introduction

Generating a GitHub Personal Access Token for API Access

Making GET Requests to Retrieve Data

Passing Data with Query Parameters

Sending Data with POST Requests

Understanding and Interpreting HTTP Status Codes

Automatic Exception Raising for HTTP Errors

Implementing Basic Authentication

Securing Requests with Token-Based Authentication

Preventing Indefinite Hangs with Timeouts

Implementing a Simple Retry Mechanism

Advanced Retries: Exponential Backoff and Jitter

Writing Robust Code with Static Typing

Section Introduction

Configuring Pylance in VS Code for Optimal Type Checking

An Introduction to Python's Type Hint System

Avoiding Common Pitfalls in Type Hinting

Applying Type Hints to Lists

Typing Dictionaries, Tuples, and Sets

Using Union and Optional for Flexible Typing

Creating Strictly-Typed Dictionaries with TypedDict

Adding Type Hints to Classes

Resolving Type Dependencies with Forward References

An Introduction to Generic Types

Creating Constrained Type Variables

Defining Bounded Type Variables

Using Generics with Classes

Applying Type Hints to Decorators

Enhancing Type Information for Decorators

Adding Type Hints to Generators

Typing Iterables and Iterators

Mastering Automated Testing with Pytest

Section Introduction

Writing Assertions with Pytest

A Practical Guide to Test-Driven Development (TDD)

Analyzing Test Failures and Handling Floating-Point Comparisons

Verifying Exception Handling in Tests

Handling Tests That Are Expected to Fail

Configuring Pytest for Your Projects

Conditionally Skipping Tests

Marking and Tracking Expected Failures

Organizing Tests with Custom Markers

Simplifying Test Setups with Fixtures

Controlling Fixture Lifecycle with Scopes

Creating Sharable Fixtures with conftest.py

Running Tests with Multiple Inputs via Parametrization

Advanced Parametrization Techniques

Core Concepts of Mocking

Using the patch Decorator and mocker Fixture

Customizing Mock Object Behavior

Simulating Exceptions and Dynamic Return Values

Advanced Side Effects with Callables

Choosing Between Mock and MagicMock

Best Practices for Structuring Python Projects

Section Introduction

Understanding Python Modules

Organizing Code with Python Packages

Structuring Projects with Subpackages

Absolute vs. Relative Imports: A Comparison

Troubleshooting Common Import Errors

Executing Modules as Scripts

Modern Project Configuration with pyproject.toml

Integrating Tests into a Multi-File Project Structure

Building a Full CI/CD Pipeline for Python Projects

Section Introduction

Creating Command-Line Interfaces with Click

Selecting the Right CI/CD Tools for Python

An Overview of Our CI/CD Pipeline Design

Setting Up the GitHub Repository and Local Workspace

Outlining the Project Implementation Plan

Defining Project Metadata with pyproject.toml

Developing the Core HTTP Checker Module

Building the CLI – Part 1

Building the CLI – Part 2

Creating a Minimal Viable Workflow with GitHub Actions

Integrating Linting and Code Formatting Checks

Incorporating Static Type and Security Analysis

Configuring Pytest for the CI/CD Pipeline

Writing Tests for the HTTP Checker

Developing Tests for the CLI

Automating Test Execution in the Workflow

Packaging the Project as a Distributable Library

Securing PyPI Publishing with OIDC

Automating Versioning with Semantic Release

Integrating Semantic Release into the Pipeline

Deploying to the TestPyPI Repository

Publishing Your Package to the Official PyPI

Optimizing the CI/CD Workflow with Release Assets

Python for DevOps: The Ultimate Hands-On Guide

By : LM Academy

Python for DevOps: The Ultimate Hands-On Guide

By: LM Academy

Overview of this book

Confirmation

Buy this book with your credits?

Submit Your Feedback

Create a Free Account To Continue Reading

Sign in to activate your 7-day free access