Pysertive ✔️

Pysertive: Assertive Python Design by Contract (DbC) Toolkit

What is it?

Pysertive is a Python library that provides decorators for implementing Design by Contract (DbC) principles. It simplifies enforcing preconditions, postconditions, and invariants in your code. Pysertive aims to be a powerful tool for ensuring code behavior and constraints, promoting secure, maintainable, and robust software development in Python.

Table of Contents

• Features
• Where to get it?
• Quick Start
• Usage
• Why Pysertive?
• Examples
• Contributing
• License

🌟 Features

The things that Pysertive does well:

• Preconditions: Ensure that function inputs meet defined criteria before execution.
• Postconditions: Validate that the function outputs conform to expected conditions after execution.
• Invariants: Guarantee that certain conditions remain true throughout the lifecycle of class instances.

Pysertive is designed with simplicity and flexibility in mind, allowing you to easily integrate rigorous contract checks into your Python code, which helps in debugging and maintaining complex systems.

📦 Where to get it?

To install Pysertive, simply use pip:

pip install pysertive

🚀 Quick Start

Here's how to quickly get started with Pysertive:

from pysertive import pre_condition, post_condition, invariant

@pre_condition(lambda x: x > 0, exception_type=ValueError, message="Input must be positive")
def sqrt(x):
    return x ** 0.5

@post_condition(lambda result: result != None, exception_type=AssertionError, message="Result cannot be None")
def fetch_data():
    return {"data": "Here is your data"}

@invariant(lambda self: self.balance >= 0, exception_type=RuntimeError, message="Insufficient funds")
class BankAccount:
    def __init__(self, balance):
        self.balance = balance

    def deposit(self, amount):
        self.balance += amount

    def withdraw(self, amount):
        self.balance -= amount  # No need to manually check for negative balance

🔧 Usage

Using Preconditions

Ensure inputs to your functions are valid:

@pre_condition(lambda age: age >= 18, exception_type=ValueError, message="Must be 18 or older")
def sign_contract(age):
    print(f"Contract signed by individual aged {age}")

Using Postconditions

Validate outputs after your functions execute:

@post_condition(lambda result: result > 0, exception_type=AssertionError, message="Profit must be positive")
def calculate_profit(revenue, costs):
    return revenue - costs

Using Invariants

Enforce class states remain consistent:

@invariant(lambda self: self.inventory_count >= 0, exception_type=RuntimeError, message="Inventory count cannot be negative")
class Warehouse:
    def __init__(self, inventory_count):
        self.inventory_count = inventory_count

    def add_stock(self, number):
        self.inventory_count += number

    def remove_stock(self, number):
        self.inventory_count -= number

❓ Why Pysertive?

• Reliability: Enforce rules consistently across your application.
• Maintainability: Easier to manage and update code with clear contractual obligations.
• Security: Prevents unexpected behaviors by strictly checking function inputs and outputs.

📚 Examples

For more detailed examples of how to use Pysertive, check out the examples.py file in the repository. This file contains examples of how to use preconditions, postconditions, and invariants in your Python code.

🤝 Contributing

Contributions are welcome! If you'd like to contribute, please check out the Contributing Guide, and feel free to open an issue or a pull request.

📜 License

Pysertive is released under the MIT License. See the License file for more details.

---

Go to Top