1. Black

Transform your code into art with just one click!

Writing functional Python code is one thing, but formatting it properly is another. Often, novice developers prioritize getting their code to run over its appearance.

Proper code formatting becomes crucial when collaborating on larger projects or within sizable teams, as it enhances code readability, aids in bug detection, and fosters teamwork.

Black is a utility that enables you to both detect errors and format your Python code simultaneously, thus boosting your productivity. As stated in their README, “By using it, you agree to relinquish control over the minutiae of manual formatting. In exchange, Black offers speed, predictability, and freedom from pycodestyle's formatting complaints. You'll conserve time and mental effort for more significant tasks.”

Installation: pip install black

black {source_file_or_directory}

> “Code is like humor. When you have to explain it, it’s bad.” — Cory House

2. MyPy

The guardian of your code’s type safety.

mypy is a static type checker that merges the advantages of dynamic (or "duck") typing with static typing. By incorporating type annotations in your Python code, mypy helps catch type errors before runtime, thus enhancing code reliability and maintainability.

Key features include early error detection, better code quality, third-party library support, and various type-checking modes.

Installation: pip install mypy

# Sample code with errors to check mypy capabilities. from typing import List, Tuple

def greet(name: int) -> str:

return f"Hello, {name}!"

def add(x: int, y: str) -> int:

return x + y

def average(numbers: List[int]) -> float:

total = sum(numbers)

return total / len(numbers)

def get_person() -> Tuple[str, int]:

return "Robert", "twenty-two"

print(greet("Dave")) print(add(20, 21)) print(average([3, 2, 4, "4"])) age = get_person()[1] print(age + 10)

3. Pydantic

Ensure your data is always in shape.

Pydantic is a popular library for data validation and settings management, providing effective tools for parsing and validating data, ensuring it conforms to specified types and constraints.

Why Use Pydantic?

• Type Hints: Governed by type annotations, simplifying your code.
• Speed: Fast performance, with core validation implemented in Rust.
• JSON Schema: Generates JSON Schema for tool integration.
• Dataclasses and TypedDicts: Validates standard library types.
• Customization: Permits custom validators and serializers.
• Ecosystem: Utilized by over 8,000 packages like FastAPI.
• Battle Tested: Downloaded 70 million times monthly, used by leading companies.

Below is a simple Python example using Pydantic:

4. Hypothesis

Uncover edge cases and bugs faster!

Hypothesis is a robust Python library for property-based testing, enabling you to write tests that generate diverse inputs to discover edge cases and bugs. Instead of manually specifying test cases, Hypothesis creates test data based on defined rules and executes your tests with this data.

Key Features

1. Property-Based Testing: Automatically generates test cases based on defined properties.
2. Data Generation: Offers various strategies for creating different data types.
3. Shrinking: When a test fails, Hypothesis minimizes the input to the simplest failing case, facilitating debugging.
4. Integrates with Existing Testing Frameworks: Works seamlessly with unittest, pytest, and others.
5. Extensibility: Enables the creation of custom strategies for generating complex data types.

Installation: pip install hypothesis

# Example With vs Without Hypothesis

5. Pre-commit

Automate Code Checks Before Commit!

Pre-commit is a powerful Python framework for managing and maintaining multi-language pre-commit hooks. It allows you to define a set of checks and transformations that automatically run on your code prior to each commit.

Installation: pip install pre-commit

1. Create a .pre-commit-config.yaml file in your project root:

repos:

• repo: https://github.com/abhayparashar31/IPL

  rev: v4.4.0

  hooks:

  • id: trailing-whitespace
  • id: end-of-file-fixer
  • id: check-yaml

• repo: https://github.com/psf/black

  rev: 23.3.0

  hooks:

  • id: black

2. Install the git hook scripts:

pre-commit install

3. Commit Code:

git commit -m "Your commit message!!!"

Pre-commit will automatically check for errors and correct them!

6. Vulture

Dead code detector.

Vulture is a Python package designed to identify and report dead code in your Python projects. “Dead code” refers to code that is never executed or utilized, which can accumulate over time as projects progress.

• Helps maintain a cleaner, more efficient codebase.
• Removing dead code can slightly enhance runtime and reduce memory consumption.

# demo.py def used_function():

return "I'm used! ?"

def unused_function():

return "I'm never called! ?"

used_variable = used_function() unused_variable = "I'm defined but never used ?"

print(used_variable)

vulture demo.py

Output: example.py:4: unused function 'unused_function' (60% confidence) example.py:8: unused variable 'unused_variable'

7. Isort

Making developers' lives easier.

Isort provides a command-line utility and library for sorting Python imports. It organizes import statements in a consistent and readable way, grouping them by type (standard library, third-party, and local) and sorting them alphabetically within each group.

• Ensures consistent import style throughout the codebase.
• Enhances code readability.
• Eases integration with other tools and IDEs like pre-commit.

Installation: pip install isort

8. PyDocstyle

Docstring Style Checker.

PyDocStyle verifies whether your docstrings align with the style recommended by PEP 257 (Docstring Conventions).

pydocstyle demo.py

9. Bandit

Identifying security issues with ease.

Bandit is a security linter for Python code, designed to uncover common security vulnerabilities in Python applications. It works by parsing the abstract syntax tree (AST) of Python code and executing a set of plugins that identify known security issues.

• Identifies potential security weaknesses in code.
• Simplifies integration into CI/CD pipelines for automatic security checks.
• Permits custom plugins and configurations.
• Detects security issues before they enter production.

import pickle import subprocess

def unsafe_deserialization(data):

return pickle.loads(data)

def command_injection(user_input):

subprocess.call("echo " + user_input, shell=True)

password = "hardcoded_password"

def get_password():

return password

10. Radon

Code Complexity Tester.

Radon is a Python package that evaluates source code and calculates various metrics, including Cyclomatic Complexity (CC), Maintainability Index (MI), Raw metrics (SLOC, comments, blank lines, etc.), and Halstead metrics (effort, difficulty, etc.).

• Assists in identifying overly complex sections of the codebase.
• Highlights areas that may require simplification.
• Offers insights into code maintainability.
• Produces reports suitable for code documentation and review.

def complex_function(a, b, c):

if a > 0:

if b > 0:

for i in range(c):

if i % 2 == 0:

print("Even")

else:

print("Odd")

else:

while b < 0:

b += 1

if b == -1:

break

elif a < 0:

if c > 0:

return c

else:

return -c

else:

return b

def simple_function():

return "Hello, World!"

Testing the complexity of the above code.py script:

random cc code.py

complex_function.py F 1:0 complex_function - B (9) F 23:0 simple_function - A (1)

Radon proves beneficial for larger projects or teams where maintaining code quality and consistency is essential. It provides objective metrics to guide code reviews, refactoring efforts, and quality enhancements.

To optimize Radon’s usage, you can create a configuration file (random.cfg) to customize its behavior:

[radon] exclude = tests/,scrapers/ cc_min = A mi_min = B

This configuration excludes specific directories and sets minimum thresholds for Cyclomatic Complexity and Maintainability Index.

Thank you for reading! If you enjoyed my content and wish to support me, here’s how:

1. Leave a Clap and your thoughts below.
2. Follow me on Medium.
3. Connect with me on LinkedIn.
4. Subscribe to My Email List to never miss another article.
5. Follow The Pythoneers publication for more similar stories.