semvec/pypi-packages huggingface dataset:
pytaskexec 0.1.0
A lightweight task execution system for concurrent operations in Python
Requires Python: >=3.6
Keywords: task, concurrent, async, threading, executor

# pytaskexec

A lightweight task execution system for concurrent operations in Python. This package provides a simple yet powerful interface for creating and managing concurrent tasks using Python's ThreadPoolExecutor.

## Features

- Easy task creation using decorators or function wrappers
- Concurrent execution using thread pools
- Flexible task management with scheduling and cancellation
- Comprehensive exception handling
- Configurable logging
- Type hints support

## Installation

```bash
pip install pytaskexec
```

## Quick Start

```python
from pytaskexec import TaskRunner, taskify
import time

# Create a task using the decorator
@taskify
def process_data(item, delay=1):
    time.sleep(delay)  # Simulate work
    return f"Processed {item}"

# Create a TaskRunner
with TaskRunner(max_workers=3) as runner:
    # Schedule multiple tasks
    task_ids = [
        runner.schedule(process_data(f"item_{i}"))
        for i in range(5)
    ]

    # Get results as they complete
    for tid in task_ids:
        result = runner.get_result(tid)
        print(result)
```

## Advanced Usage

### Creating Tasks

There are two ways to create tasks:

1. Using the `@taskify` decorator:
```python
@taskify
def my_task(x, y):
    return x + y

task = my_task(1, 2)  # Creates a Task object
```

2. Using the `wrap_as_task` function:
```python
from pytaskexec import wrap_as_task

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

task = wrap_as_task(my_function, 1, 2)  # Creates a Task object
```

### Task Management

```python
with TaskRunner(name="my_runner", max_workers=5) as runner:
    # Schedule tasks
    tid1 = runner.schedule(my_task(1, 2))
    tid2 = runner.schedule(my_task(3, 4))

    # Wait for specific tasks
    runner.block(taskids=[tid1, tid2])

    # Get results with timeout
    try:
        result = runner.get_result(tid1, timeout=5)
    except concurrent.futures.TimeoutError:
        runner.cancel_task(tid1)

    # Cancel all pending tasks
    runner.cancel_pending()
```

### Debug Logging

Set the environment variable `PYTASKEXEC_DEBUG` to enable debug logging:

```bash
export PYTASKEXEC_DEBUG=1  # Linux/Mac
set PYTASKEXEC_DEBUG=1      # Windows
```

## Development

### Setting up the Development Environment

1. Clone the repository:
```bash
git clone https://github.com/anandan-bs/pytaskexec.git
cd pytaskexec
```

2. Create a virtual environment:
```bash
python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate
```

3. Install development dependencies:
```bash
pip install -r requirements.txt
```

### Running Tests

```bash
pytest tests/
```

### Code Style

This project uses:
- Black for code formatting
- Flake8 for linting
- MyPy for type checking

## Contributing

1. Fork the repository
2. Create a feature branch
3. Make your changes
4. Run tests and ensure they pass
5. Submit a pull request

## License

This project is licensed under the MIT License. See the LICENSE file for details.
YoshiOwnLib 0.1
A Python package for data analysis and visualization using Pandas, NumPy, Matplotlib, and Seaborn.
Requires Python: >=3.6

# YoshiOwnLib 📊

YoshiOwnLib is a lightweight and easy-to-use Python library built to accelerate Exploratory Data Analysis (EDA) and preliminary dataset inspection for data science projects. It wraps essential Pandas, NumPy, Seaborn, and Matplotlib utilities to help you quickly understand the structure, quality, and relationships within your dataset.

---

## ✨ Features



- ✅ Quick DataFrame summary: shape, datatypes, missing values, and statistics  
- ✅ Visualize correlation matrix with heatmaps  
- ✅ Detect outliers using the IQR method  
- ✅ Plot numeric feature distributions  
- ✅ Report missing values as proportions  
- ✅ Get value counts for all categorical columns  

---

## 📦 Installation


bash
pip install YoshiOwnLib


Since this is a custom library, clone or copy the source code into your project directory or package it using setuptools if needed.

bash
# Clone this repository or include the file directly
git clone https://github.com/yoshithanunna33/YoshiOwnLib.git




In your Python project:




from YoshiOwnLib import df_summary, missing_report, correlation_matrix, outlier_summary, plot_distributions, value_counts_all




🧪 How to Use


1. df_summary(df)
Provides an overall summary of the DataFrame including shape, data types, missing values, and descriptive statistics.



import pandas as pd
from YoshiOwnLib import df_summary

df = pd.read_csv("your_data.csv")
df_summary(df)


2. missing_report(df)
Returns a Series with the proportion of missing values in each column (sorted descending).


from YoshiOwnLib import missing_report

missing_report(df)


3. correlation_matrix(df)
Plots a heatmap of correlation coefficients for all numeric features in the DataFrame.


from YoshiOwnLib import correlation_matrix

correlation_matrix(df)



4. outlier_summary(df)
Returns a count of outliers per numeric column using the IQR method.

from YoshiOwnLib import outlier_summary

outlier_summary(df)


5. plot_distributions(df)
Displays histograms of all numeric columns in the DataFrame.


from YoshiOwnLib import plot_distributions

plot_distributions(df)


6. value_counts_all(df)
Returns a dictionary with value counts for all object (categorical) columns.


from YoshiOwnLib import value_counts_all

value_counts_all(df)



🧑‍💻 Developer
Pavan Aditya Kumar Gorrela
Artificial Intelligence & Data Science | ML & Web Dev Enthusiast

📜 License
This project is licensed under the MIT License. Feel free to use and modify!

🙌 Contributing
Pull requests are welcome. For major changes, please open an issue first to discuss what you'd like to change.

🧠 Future Features
Advanced outlier detection (Z-score, Isolation Forest)

Interactive plots using Plotly

Automatic report generation using pandas-profiling or sweetviz


Let me know if you'd like help setting this up as a proper Python package