Metadata-Version: 2.1
Name: parallize
Version: 0.1.4
Summary: Parallize is a Python package that provides utilities to parallelize both synchronous and asynchronous functions using the `concurrent.futures.ProcessPoolExecutor`.
Author: vikyw89
Author-email: vikyw89@gmail.com
Requires-Python: >=3.10,<4.0
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Description-Content-Type: text/markdown

# Parallize

Parallize is a Python package that provides utilities to parallelize synchronous functions using the `concurrent.futures.ProcessPoolExecutor` and convert it into async functions to prevent the main thread from blocking. This allows you to execute functions in separate processes, leveraging multiple CPU cores for improved performance.

## Features

- **Parallelize Synchronous Functions**: Execute synchronous functions in parallel using multiple processes.
- **Parallelize Asynchronous Functions**: Execute asynchronous functions in parallel using multiple processes.
- **Customizable Worker Count**: Specify the maximum number of worker processes to use, or let the package use the number of available CPU cores by default.

## Mini Benchmark

Here are the updated benchmark results comparing serial and parallel execution times using the `test_aparallize.py` test case:

| Test Case            | Concurrent Execution Time | Parallel Execution Time | Speedup | Tasks Count |
| -------------------- | ------------------------- | ----------------------- | ------- | ----------- |
| `test_aparallize_fn` | 0:00:17.215937            | 0:00:08.293026          | 2.08x   | 2           |
| `test_aparallize_10` | 0:01:25.070893            | 0:00:13.997451          | 5.94x   | 10          |

### Benchmark Details

- **Concurrent Execution Time**: The time taken to execute the CPU-bound task concurrently using a `ThreadPoolExecutor`.
- **Parallel Execution Time**: The time taken to execute the same task in parallel using the `aparallize` decorator.
- **Speedup**: The ratio of serial execution time to parallel execution time, indicating the performance improvement achieved by parallelizing the task.

## Installation

To install Parallize, you can use pip:

```bash
pip install parallize
```

## Usage

### Parallelizing Synchronous Functions Using Decorator

To parallelize a synchronous function, use the `parallize` decorator:

```python
from parallize import parallize

@parallize
def my_function(x, y):
    return x + y

# Call the function as usual
result = my_function(1, 2)
print(result)  # This will be executed in a separate process
```

### Parallelizing Asynchronous Functions Using Decorator

To parallelize an asynchronous function, use the `aparallize` decorator:

```python
import asyncio
from parallize import aparallize

@aparallize
async def my_async_function(x, y):
    await asyncio.sleep(1)
    return x + y

# Call the function as usual
result = my_async_function(1, 2)
print(result)  # This will be executed in a separate process
```

### Another Usage Without Decorator

```python
from parallize import parallize

def my_function(x, y):
    return x + y

# Call the function as usual
result = parallize(my_function)(1, 2)
print(result)  # This will be executed in a separate process
```

### Customizing the Number of Workers

You can specify the maximum number of worker processes to use by passing the `max_workers` argument to the decorator:

```python
@parallize(max_workers=4)
def my_function(x, y):
    return x + y

@aparallize(max_workers=4)
async def my_async_function(x, y):
    await asyncio.sleep(1)
    return x + y
```

## License

This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.

## Contributing

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

## Issues

If you encounter any issues or have suggestions for improvements, please open an issue on the [GitHub repository](https://github.com/vikyw89/parallize/issues).

## Acknowledgments

- Thanks to the Python community for providing powerful tools and libraries for parallel processing.

@vikyw89-20240804

