GitLocker: The Coding Marketplace

Description:

pysertive 0.0.1

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