Metadata-Version: 2.1
Name: python-wrap
Version: 0.1.0
Summary: A comprehensive collection of Python decorators and utility functions for enhanced development workflows
Home-page: https://github.com/Pythondeveloper6/PythonWrap
License: MIT
Keywords: decorators,utilities,python,development,tools,python
Author: Mahmoud Ahmed
Author-email: contact.mahmoudahmed@gmail.com
Maintainer: Mahmoud Ahmed
Maintainer-email: contact.mahmoudahmed@gmail.com
Requires-Python: >=3.8,<4.0
Classifier: Development Status :: 4 - Beta
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: OS Independent
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.8
Classifier: Programming Language :: Python :: 3.9
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Classifier: Programming Language :: Python :: 3.13
Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
Classifier: Topic :: Software Development :: Libraries :: Python Modules
Classifier: Typing :: Typed
Requires-Dist: typing-extensions (>=4.7.1,<5.0.0)
Requires-Dist: wrapt (>=1.15.0,<2.0.0)
Project-URL: Bug Tracker, https://github.com/Pythondeveloper6/PythonWrap/issues
Project-URL: Changelog, https://github.com/Pythondeveloper6/PythonWrap/blob/main/CHANGELOG.md
Project-URL: Documentation, https://python-wrap.readthedocs.io
Project-URL: Repository, https://github.com/Pythondeveloper6/PythonWrap
Description-Content-Type: text/markdown

# PythonWrap

A comprehensive collection of Python decorators and utility functions to enhance your development workflow.

## Installation

```bash
pip install python-wrap
```

## Features

PythonWrap provides a rich set of decorators that can be used either as decorators or as standalone functions:

### Performance & Profiling
- `@timing`: Measure function execution time
- `@profile`: Profile function performance
- `@benchmark`: Compare execution times
- `@measure_memory`: Track memory usage

### Error Handling & Reliability
- `@retry`: Retry failed operations
- `@retry_on_exception`: Retry on specific exceptions
- `@timeout`: Set execution time limits
- `@revert_on_failure`: Automatic state rollback on failure

### Caching & Optimization
- `@memoize`: Cache function results
- `@cache`: Time-based result caching
- `@once`: Single execution guarantee

### Debugging & Logging
- `@log_args`: Log function arguments
- `@log_return`: Log return values
- `@trace`: Log call stack traces
- `@audit`: Comprehensive function call auditing

### Type Safety & Validation
- `@check_type`: Runtime type checking
- `@validate_args`: Custom argument validation

### Development Tools
- `@deprecate`: Mark deprecated functions
- `@no_debug`: Disable debug output
- `@mock_data`: Easy data mocking
- `@rate_limit`: Control execution frequency

### Concurrency
- `@run_in_thread`: Asynchronous execution
- `@transactional`: Atomic operations

## Usage Examples

### Using as Decorators

```python
from python_wrap import timing, retry, memoize

# As a decorator
@timing
def slow_operation():
    time.sleep(1)
    return "Done"

# As a decorator with parameters
@retry(max_attempts=3, delay=1.0)
def unreliable_operation():
    return api_call()

# Simple decorator
@memoize
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)
```

### Using as Functions

```python
from python_wrap import timing, retry, memoize

# Using timing as a function
def slow_operation():
    time.sleep(1)
    return "Done"

result = timing(slow_operation)()

# Using retry as a function
def unreliable_operation():
    return api_call()

result = retry(unreliable_operation, max_attempts=3, delay=1.0)()

# Using memoize as a function
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

memoized_fib = memoize(fibonacci)
result = memoized_fib(10)
```

### Advanced Usage

```python
from python_wrap import validate_args, check_type, timeout

# As decorators
@validate_args(x=lambda x: x > 0, y=lambda y: y < 100)
def process_numbers(x, y):
    return x + y

@check_type(name=str, age=int)
def create_user(name, age):
    return {"name": name, "age": age}

# As functions
def long_running_task():
    process_large_dataset()

timed_task = timeout(5)(long_running_task)
result = timed_task()
```

### Combining Multiple Functions

```python
from python_wrap import timing, retry, log_args

# As decorators
@timing
@retry(max_attempts=3)
@log_args
def complex_operation(x, y):
    return expensive_calculation(x, y)

# As functions
def complex_operation(x, y):
    return expensive_calculation(x, y)

# Compose functions
monitored_op = timing(retry(log_args(complex_operation), max_attempts=3))
result = monitored_op(1, 2)
```

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

## License

This project is licensed under the MIT License - see the LICENSE file for details.
