pipelinehub 0.1.0__tar.gz

pipelinehub-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Rahul Paul
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pipelinehub-0.1.0/PKG-INFO

@@ -0,0 +1,192 @@
+Metadata-Version: 2.1
+Name: pipelinehub
+Version: 0.1.0
+Summary: A flexible data pipeline library for custom data processing workflows
+Home-page: https://github.com/rahulxj100/pipelinehub
+Author: Rahul Paul
+Author-email: Rahul Paul <paul.rahulxj100@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/rahulxj100/pipelinehub
+Project-URL: Bug Reports, https://github.com/rahulxj100/pipelinehub/issues
+Project-URL: Source, https://github.com/rahulxj100/pipelinehub
+Keywords: pipeline,data,processing,workflow,etl
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+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: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=6.0; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: flake8; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+
+# PipelineHub
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+
+A flexible Python library for creating custom data processing workflows with ease.
+
+## ✨ Features
+
+- 🔧 **Flexible**: Add any callable function as a processing step
+- 🔗 **Chainable**: Fluent method chaining for clean, readable code
+- 🐛 **Debuggable**: Verbose mode shows data flow between steps
+- 🧪 **Testable**: Clear error handling with step identification
+- 📦 **Lightweight**: Zero external dependencies
+- 🎯 **Type-friendly**: Full type hints for better IDE support
+- 🚀 **Performance**: Minimal overhead for maximum speed
+- 🔄 **Reusable**: Create pipelines once, use with different datasets
+
+## Installation
+```bash
+pip install pipelinehub
+```
+
+## 📖 Quick Start
+```python
+from pipelinehub import DataPipeline, normalize_data, square_numbers
+
+# Create a pipeline with multiple steps
+pipeline = DataPipeline()
+pipeline.add_step(lambda x: [i for i in x if i > 0], "filter_positive")
+pipeline.add_step(square_numbers, "square")
+pipeline.add_step(normalize_data, "normalize")
+
+# Execute with sample data
+data = [-2, -1, 0, 1, 2, 3, 4, 5]
+result = pipeline.execute(data, verbose=True)
+
+print(result)
+```
+## 🔗 Method Chaining
+Create pipelines fluently with method chaining:
+
+```python
+from pipelinehub import DataPipeline, add_constant
+
+# Chain operations together
+result = (DataPipeline()
+          .add_step(lambda x: [i for i in x if i % 2 == 0], "filter_even")
+          .add_step(add_constant(10), "add_10")  
+          .add_step(lambda x: sorted(x, reverse=True), "sort_desc")
+          .execute([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]))
+
+print(result) 
+```
+
+## 📚 Comprehensive Examples
+
+### Data Cleaning Pipeline
+```python 
+from pipelinehub import DataPipeline, outlier_removal, normalize_data, calculate_stats
+
+# Create a data cleaning pipeline
+cleaning_pipeline = (DataPipeline()
+    .add_step(lambda x: [float(i) for i in x if i is not None], "convert_and_filter")
+    .add_step(lambda x: outlier_removal(x, threshold=2.5), "remove_outliers") 
+    .add_step(normalize_data, "normalize")
+    .add_step(calculate_stats, "final_stats"))
+
+# Process messy data
+messy_data = [1, 2, 3, None, 100, 4, 5, 6, 7, 8, 9]
+stats = cleaning_pipeline.execute(messy_data, verbose=True)
+print(stats)
+```
+### Text Processing Pipeline
+```python
+import re
+from pipelinehub import DataPipeline
+
+def clean_text(text):
+    """Remove special characters and extra whitespace."""
+    text = re.sub(r'[^a-zA-Z0-9\s]', '', text)
+    return ' '.join(text.split())
+
+def extract_keywords(words, min_length=4):
+    """Extract words longer than min_length."""
+    return [word for word in words if len(word) >= min_length]
+
+# Build text processing pipeline
+text_pipeline = (DataPipeline()
+    .add_step(str.lower, "lowercase")
+    .add_step(clean_text, "clean")
+    .add_step(str.split, "tokenize") 
+    .add_step(lambda words: extract_keywords(words, min_length=4), "extract_keywords")
+    .add_step(lambda words: sorted(set(words)), "unique_and_sort"))
+
+# Process text
+text = "Hello World! This is a Sample Text for Processing... With special chars!!!"
+keywords = text_pipeline.execute(text, verbose=True)
+print(keywords)
+```
+
+## Pipeline Management
+```python
+pipeline = DataPipeline()
+pipeline.add_step(lambda x: [i*2 for i in x], "double")
+pipeline.add_step(lambda x: [i+1 for i in x], "add_one")
+
+# Inspect pipeline
+print(len(pipeline))  # 2
+print(pipeline.get_steps())  # ['double', 'add_one']
+print(pipeline)  # DataPipeline(2 steps: double, add_one)
+
+# Remove steps
+pipeline.remove_step(0)  # Remove first step
+print(pipeline.get_steps())  # ['add_one']
+
+# Clear all steps
+pipeline.clear_steps()
+print(len(pipeline))  # 0
+```
+## 🚀 Performance Tips
+
+- Use built-in functions when possible - they're optimized
+- Avoid creating large intermediate data structures
+- Consider using generators for large datasets:
+```python
+def generator_step(data):
+    """Use generator for memory efficiency."""
+    for item in data:
+        if item > 0:
+            yield item * 2
+
+pipeline = DataPipeline().add_step(lambda x: list(generator_step(x)), "process")
+```
+
+## 🤝 Contributing
+Contributions are welcome! Here's how to get started:
+
+- Fork the repository
+- Create a feature branch: git checkout -b feature/amazing-feature
+- Make your changes and add tests
+- Run tests: pytest tests/
+- Commit your changes: git commit -m 'Add amazing feature'
+- Push to branch: git push origin feature/amazing-feature
+- Open a Pull Request
+
+## 📄 License
+This project is licensed under the MIT License - see the LICENSE file for details.
+## 🙋‍♂️ Support
+
+Discussions: GitHub Discussions
+
+## 🎉 Acknowledgments
+
+- Inspired by functional programming and Unix pipes philosophy
+- Built with ❤️ for the Python community
+- Thanks to all contributors and users!
+
+

pipelinehub-0.1.0/README.md

@@ -0,0 +1,159 @@
+# PipelineHub
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+
+A flexible Python library for creating custom data processing workflows with ease.
+
+## ✨ Features
+
+- 🔧 **Flexible**: Add any callable function as a processing step
+- 🔗 **Chainable**: Fluent method chaining for clean, readable code
+- 🐛 **Debuggable**: Verbose mode shows data flow between steps
+- 🧪 **Testable**: Clear error handling with step identification
+- 📦 **Lightweight**: Zero external dependencies
+- 🎯 **Type-friendly**: Full type hints for better IDE support
+- 🚀 **Performance**: Minimal overhead for maximum speed
+- 🔄 **Reusable**: Create pipelines once, use with different datasets
+
+## Installation
+```bash
+pip install pipelinehub
+```
+
+## 📖 Quick Start
+```python
+from pipelinehub import DataPipeline, normalize_data, square_numbers
+
+# Create a pipeline with multiple steps
+pipeline = DataPipeline()
+pipeline.add_step(lambda x: [i for i in x if i > 0], "filter_positive")
+pipeline.add_step(square_numbers, "square")
+pipeline.add_step(normalize_data, "normalize")
+
+# Execute with sample data
+data = [-2, -1, 0, 1, 2, 3, 4, 5]
+result = pipeline.execute(data, verbose=True)
+
+print(result)
+```
+## 🔗 Method Chaining
+Create pipelines fluently with method chaining:
+
+```python
+from pipelinehub import DataPipeline, add_constant
+
+# Chain operations together
+result = (DataPipeline()
+          .add_step(lambda x: [i for i in x if i % 2 == 0], "filter_even")
+          .add_step(add_constant(10), "add_10")  
+          .add_step(lambda x: sorted(x, reverse=True), "sort_desc")
+          .execute([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]))
+
+print(result) 
+```
+
+## 📚 Comprehensive Examples
+
+### Data Cleaning Pipeline
+```python 
+from pipelinehub import DataPipeline, outlier_removal, normalize_data, calculate_stats
+
+# Create a data cleaning pipeline
+cleaning_pipeline = (DataPipeline()
+    .add_step(lambda x: [float(i) for i in x if i is not None], "convert_and_filter")
+    .add_step(lambda x: outlier_removal(x, threshold=2.5), "remove_outliers") 
+    .add_step(normalize_data, "normalize")
+    .add_step(calculate_stats, "final_stats"))
+
+# Process messy data
+messy_data = [1, 2, 3, None, 100, 4, 5, 6, 7, 8, 9]
+stats = cleaning_pipeline.execute(messy_data, verbose=True)
+print(stats)
+```
+### Text Processing Pipeline
+```python
+import re
+from pipelinehub import DataPipeline
+
+def clean_text(text):
+    """Remove special characters and extra whitespace."""
+    text = re.sub(r'[^a-zA-Z0-9\s]', '', text)
+    return ' '.join(text.split())
+
+def extract_keywords(words, min_length=4):
+    """Extract words longer than min_length."""
+    return [word for word in words if len(word) >= min_length]
+
+# Build text processing pipeline
+text_pipeline = (DataPipeline()
+    .add_step(str.lower, "lowercase")
+    .add_step(clean_text, "clean")
+    .add_step(str.split, "tokenize") 
+    .add_step(lambda words: extract_keywords(words, min_length=4), "extract_keywords")
+    .add_step(lambda words: sorted(set(words)), "unique_and_sort"))
+
+# Process text
+text = "Hello World! This is a Sample Text for Processing... With special chars!!!"
+keywords = text_pipeline.execute(text, verbose=True)
+print(keywords)
+```
+
+## Pipeline Management
+```python
+pipeline = DataPipeline()
+pipeline.add_step(lambda x: [i*2 for i in x], "double")
+pipeline.add_step(lambda x: [i+1 for i in x], "add_one")
+
+# Inspect pipeline
+print(len(pipeline))  # 2
+print(pipeline.get_steps())  # ['double', 'add_one']
+print(pipeline)  # DataPipeline(2 steps: double, add_one)
+
+# Remove steps
+pipeline.remove_step(0)  # Remove first step
+print(pipeline.get_steps())  # ['add_one']
+
+# Clear all steps
+pipeline.clear_steps()
+print(len(pipeline))  # 0
+```
+## 🚀 Performance Tips
+
+- Use built-in functions when possible - they're optimized
+- Avoid creating large intermediate data structures
+- Consider using generators for large datasets:
+```python
+def generator_step(data):
+    """Use generator for memory efficiency."""
+    for item in data:
+        if item > 0:
+            yield item * 2
+
+pipeline = DataPipeline().add_step(lambda x: list(generator_step(x)), "process")
+```
+
+## 🤝 Contributing
+Contributions are welcome! Here's how to get started:
+
+- Fork the repository
+- Create a feature branch: git checkout -b feature/amazing-feature
+- Make your changes and add tests
+- Run tests: pytest tests/
+- Commit your changes: git commit -m 'Add amazing feature'
+- Push to branch: git push origin feature/amazing-feature
+- Open a Pull Request
+
+## 📄 License
+This project is licensed under the MIT License - see the LICENSE file for details.
+## 🙋‍♂️ Support
+
+Discussions: GitHub Discussions
+
+## 🎉 Acknowledgments
+
+- Inspired by functional programming and Unix pipes philosophy
+- Built with ❤️ for the Python community
+- Thanks to all contributors and users!
+
+

pipelinehub-0.1.0/pipelinehub/__init__.py

@@ -0,0 +1,29 @@
+"""
+PipelineHub - A library for creating custom data processing workflows.
+"""
+
+from .pipeline import DataPipeline
+from .utils import (
+    filter_numbers,
+    square_numbers,
+    sum_data,
+    normalize_data,
+    add_constant,
+    calculate_stats,
+    outlier_removal,
+)
+
+__version__ = "1.0.0"
+__author__ = "Rahul Paul"
+__email__ = "paul.rahulxj100@gmail.com"
+
+__all__ = [
+    "DataPipeline",
+    "filter_numbers",
+    "square_numbers", 
+    "sum_data",
+    "normalize_data",
+    "add_constant",
+    "calculate_stats",
+    "outlier_removal",
+]

pipelinehub-0.1.0/pipelinehub/pipeline.py

@@ -0,0 +1,151 @@
+"""
+Core DataPipeline class for creating flexible data processing workflows.
+"""
+
+from typing import Any, Callable, List, Optional, Union
+
+
+class DataPipeline:
+    """
+    A flexible data pipeline that allows adding custom processing steps.
+    Each step is a function that transforms the data.
+    """
+    
+    def __init__(self, data: Any = None):
+        """
+        Initialize a new DataPipeline.
+        
+        Args:
+            data: Optional initial data for the pipeline
+        """
+        self.data = data
+        self.steps: List[Callable] = []
+        self.step_names: List[str] = []
+    
+    def add_step(self, func: Callable, name: Optional[str] = None) -> "DataPipeline":
+        """
+        Add a custom processing step to the pipeline.
+        
+        Args:
+            func: A function that takes data as input and returns transformed data
+            name: Optional name for the step (for debugging/logging)
+        
+        Returns:
+            self (for method chaining)
+            
+        Raises:
+            ValueError: If func is not callable
+        """
+        if not callable(func):
+            raise ValueError("Step must be a callable function")
+        
+        self.steps.append(func)
+        step_name = name or getattr(func, '__name__', f"step_{len(self.steps)}")
+        self.step_names.append(step_name)
+        
+        return self
+    
+    def set_data(self, data: Any) -> "DataPipeline":
+        """
+        Set the initial data for the pipeline.
+        
+        Args:
+            data: The data to process
+            
+        Returns:
+            self (for method chaining)
+        """
+        self.data = data
+        return self
+    
+    def execute(self, data: Any = None, verbose: bool = False) -> Any:
+        """
+        Execute all steps in the pipeline.
+        
+        Args:
+            data: Optional data to process (overrides instance data)
+            verbose: Print step-by-step execution info
+            
+        Returns:
+            Transformed data after all steps
+            
+        Raises:
+            ValueError: If no data is provided
+            RuntimeError: If any step fails during execution
+        """
+        current_data = data if data is not None else self.data
+        
+        if current_data is None:
+            raise ValueError("No data provided. Use set_data() or pass data to execute()")
+        
+        if verbose:
+            print(f"Starting pipeline with {len(self.steps)} steps")
+            data_info = self._get_data_info(current_data)
+            print(f"Initial data: {data_info}")
+        
+        for i, (step, step_name) in enumerate(zip(self.steps, self.step_names)):
+            try:
+                if verbose:
+                    print(f"\nStep {i+1}: {step_name}")
+                
+                current_data = step(current_data)
+                
+                if verbose:
+                    data_info = self._get_data_info(current_data)
+                    print(f"  Output: {data_info}")
+                    
+            except Exception as e:
+                raise RuntimeError(f"Error in step {i+1} ({step_name}): {str(e)}")
+        
+        return current_data
+    
+    def clear_steps(self) -> "DataPipeline":
+        """
+        Remove all steps from the pipeline.
+        
+        Returns:
+            self (for method chaining)
+        """
+        self.steps.clear()
+        self.step_names.clear()
+        return self
+    
+    def remove_step(self, index: int) -> "DataPipeline":
+        """
+        Remove a step by index.
+        
+        Args:
+            index: Index of the step to remove
+            
+        Returns:
+            self (for method chaining)
+        """
+        if 0 <= index < len(self.steps):
+            self.steps.pop(index)
+            self.step_names.pop(index)
+        return self
+    
+    def get_steps(self) -> List[str]:
+        """
+        Get list of step names.
+        
+        Returns:
+            List of step names
+        """
+        return self.step_names.copy()
+    
+    def _get_data_info(self, data: Any) -> str:
+        """Get descriptive info about data for verbose output."""
+        data_type = type(data).__name__
+        if hasattr(data, '__len__'):
+            return f"{data_type} with {len(data)} elements"
+        return f"{data_type}"
+    
+    def __len__(self) -> int:
+        """Return number of steps in the pipeline."""
+        return len(self.steps)
+    
+    def __repr__(self) -> str:
+        """String representation of the pipeline."""
+        steps_str = ', '.join(self.step_names) if self.step_names else "no steps"
+        return f"DataPipeline({len(self.steps)} steps: {steps_str})"

pipelinehub-0.1.0/pipelinehub/utils.py

@@ -0,0 +1,121 @@
+"""
+Utility functions for common data processing operations.
+"""
+
+from typing import Any, Callable, Dict, List, Union
+
+
+def filter_numbers(data: List[Union[int, float]], min_val: Union[int, float] = 0) -> List[Union[int, float]]:
+    """
+    Filter numbers greater than min_val.
+    
+    Args:
+        data: List of numbers
+        min_val: Minimum value threshold
+        
+    Returns:
+        Filtered list of numbers
+    """
+    return [x for x in data if x > min_val]
+
+
+def square_numbers(data: List[Union[int, float]]) -> List[Union[int, float]]:
+    """
+    Square all numbers in the data.
+    
+    Args:
+        data: List of numbers
+        
+    Returns:
+        List of squared numbers
+    """
+    return [x ** 2 for x in data]
+
+
+def sum_data(data: List[Union[int, float]]) -> Union[int, float]:
+    """
+    Sum all numbers in the data.
+    
+    Args:
+        data: List of numbers
+        
+    Returns:
+        Sum of all numbers
+    """
+    return sum(data)
+
+
+def normalize_data(data: List[Union[int, float]]) -> List[float]:
+    """
+    Normalize data to 0-1 range.
+    
+    Args:
+        data: List of numbers
+        
+    Returns:
+        Normalized list of numbers
+    """
+    if not data:
+        return data
+    min_val, max_val = min(data), max(data)
+    if min_val == max_val:
+        return [0.0] * len(data)
+    return [(x - min_val) / (max_val - min_val) for x in data]
+
+
+def add_constant(constant: Union[int, float]) -> Callable:
+    """
+    Create a function that adds a constant to all values.
+    
+    Args:
+        constant: Value to add to each element
+        
+    Returns:
+        Function that adds the constant to data
+    """
+    def add_const(data: List[Union[int, float]]) -> List[Union[int, float]]:
+        return [x + constant for x in data]
+    
+    add_const.__name__ = f"add_{constant}"
+    return add_const
+
+
+def calculate_stats(data: List[Union[int, float]]) -> Dict[str, Union[int, float]]:
+    """
+    Calculate basic statistics.
+    
+    Args:
+        data: List of numbers
+        
+    Returns:
+        Dictionary with count, mean, min, max
+    """
+    if not data:
+        return {}
+    return {
+        'count': len(data),
+        'mean': sum(data) / len(data),
+        'min': min(data),
+        'max': max(data)
+    }
+
+
+def outlier_removal(data: List[Union[int, float]], threshold: float = 2.0) -> List[Union[int, float]]:
+    """
+    Remove outliers using simple threshold method.
+    
+    Args:
+        data: List of numbers
+        threshold: Standard deviation threshold
+        
+    Returns:
+        Data with outliers removed
+    """
+    if len(data) < 2:
+        return data
+    
+    mean = sum(data) / len(data)
+    variance = sum((x - mean) ** 2 for x in data) / len(data)
+    std_dev = variance ** 0.5
+    
+    return [x for x in data if abs(x - mean) <= threshold * std_dev]

pipelinehub-0.1.0/pipelinehub.egg-info/PKG-INFO

@@ -0,0 +1,192 @@
+Metadata-Version: 2.1
+Name: pipelinehub
+Version: 0.1.0
+Summary: A flexible data pipeline library for custom data processing workflows
+Home-page: https://github.com/rahulxj100/pipelinehub
+Author: Rahul Paul
+Author-email: Rahul Paul <paul.rahulxj100@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/rahulxj100/pipelinehub
+Project-URL: Bug Reports, https://github.com/rahulxj100/pipelinehub/issues
+Project-URL: Source, https://github.com/rahulxj100/pipelinehub
+Keywords: pipeline,data,processing,workflow,etl
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+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: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=6.0; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: flake8; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+
+# PipelineHub
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+
+A flexible Python library for creating custom data processing workflows with ease.
+
+## ✨ Features
+
+- 🔧 **Flexible**: Add any callable function as a processing step
+- 🔗 **Chainable**: Fluent method chaining for clean, readable code
+- 🐛 **Debuggable**: Verbose mode shows data flow between steps
+- 🧪 **Testable**: Clear error handling with step identification
+- 📦 **Lightweight**: Zero external dependencies
+- 🎯 **Type-friendly**: Full type hints for better IDE support
+- 🚀 **Performance**: Minimal overhead for maximum speed
+- 🔄 **Reusable**: Create pipelines once, use with different datasets
+
+## Installation
+```bash
+pip install pipelinehub
+```
+
+## 📖 Quick Start
+```python
+from pipelinehub import DataPipeline, normalize_data, square_numbers
+
+# Create a pipeline with multiple steps
+pipeline = DataPipeline()
+pipeline.add_step(lambda x: [i for i in x if i > 0], "filter_positive")
+pipeline.add_step(square_numbers, "square")
+pipeline.add_step(normalize_data, "normalize")
+
+# Execute with sample data
+data = [-2, -1, 0, 1, 2, 3, 4, 5]
+result = pipeline.execute(data, verbose=True)
+
+print(result)
+```
+## 🔗 Method Chaining
+Create pipelines fluently with method chaining:
+
+```python
+from pipelinehub import DataPipeline, add_constant
+
+# Chain operations together
+result = (DataPipeline()
+          .add_step(lambda x: [i for i in x if i % 2 == 0], "filter_even")
+          .add_step(add_constant(10), "add_10")  
+          .add_step(lambda x: sorted(x, reverse=True), "sort_desc")
+          .execute([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]))
+
+print(result) 
+```
+
+## 📚 Comprehensive Examples
+
+### Data Cleaning Pipeline
+```python 
+from pipelinehub import DataPipeline, outlier_removal, normalize_data, calculate_stats
+
+# Create a data cleaning pipeline
+cleaning_pipeline = (DataPipeline()
+    .add_step(lambda x: [float(i) for i in x if i is not None], "convert_and_filter")
+    .add_step(lambda x: outlier_removal(x, threshold=2.5), "remove_outliers") 
+    .add_step(normalize_data, "normalize")
+    .add_step(calculate_stats, "final_stats"))
+
+# Process messy data
+messy_data = [1, 2, 3, None, 100, 4, 5, 6, 7, 8, 9]
+stats = cleaning_pipeline.execute(messy_data, verbose=True)
+print(stats)
+```
+### Text Processing Pipeline
+```python
+import re
+from pipelinehub import DataPipeline
+
+def clean_text(text):
+    """Remove special characters and extra whitespace."""
+    text = re.sub(r'[^a-zA-Z0-9\s]', '', text)
+    return ' '.join(text.split())
+
+def extract_keywords(words, min_length=4):
+    """Extract words longer than min_length."""
+    return [word for word in words if len(word) >= min_length]
+
+# Build text processing pipeline
+text_pipeline = (DataPipeline()
+    .add_step(str.lower, "lowercase")
+    .add_step(clean_text, "clean")
+    .add_step(str.split, "tokenize") 
+    .add_step(lambda words: extract_keywords(words, min_length=4), "extract_keywords")
+    .add_step(lambda words: sorted(set(words)), "unique_and_sort"))
+
+# Process text
+text = "Hello World! This is a Sample Text for Processing... With special chars!!!"
+keywords = text_pipeline.execute(text, verbose=True)
+print(keywords)
+```
+
+## Pipeline Management
+```python
+pipeline = DataPipeline()
+pipeline.add_step(lambda x: [i*2 for i in x], "double")
+pipeline.add_step(lambda x: [i+1 for i in x], "add_one")
+
+# Inspect pipeline
+print(len(pipeline))  # 2
+print(pipeline.get_steps())  # ['double', 'add_one']
+print(pipeline)  # DataPipeline(2 steps: double, add_one)
+
+# Remove steps
+pipeline.remove_step(0)  # Remove first step
+print(pipeline.get_steps())  # ['add_one']
+
+# Clear all steps
+pipeline.clear_steps()
+print(len(pipeline))  # 0
+```
+## 🚀 Performance Tips
+
+- Use built-in functions when possible - they're optimized
+- Avoid creating large intermediate data structures
+- Consider using generators for large datasets:
+```python
+def generator_step(data):
+    """Use generator for memory efficiency."""
+    for item in data:
+        if item > 0:
+            yield item * 2
+
+pipeline = DataPipeline().add_step(lambda x: list(generator_step(x)), "process")
+```
+
+## 🤝 Contributing
+Contributions are welcome! Here's how to get started:
+
+- Fork the repository
+- Create a feature branch: git checkout -b feature/amazing-feature
+- Make your changes and add tests
+- Run tests: pytest tests/
+- Commit your changes: git commit -m 'Add amazing feature'
+- Push to branch: git push origin feature/amazing-feature
+- Open a Pull Request
+
+## 📄 License
+This project is licensed under the MIT License - see the LICENSE file for details.
+## 🙋‍♂️ Support
+
+Discussions: GitHub Discussions
+
+## 🎉 Acknowledgments
+
+- Inspired by functional programming and Unix pipes philosophy
+- Built with ❤️ for the Python community
+- Thanks to all contributors and users!
+
+

pipelinehub-0.1.0/pipelinehub.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+LICENSE
+README.md
+pyproject.toml
+setup.py
+./pipelinehub/__init__.py
+./pipelinehub/pipeline.py
+./pipelinehub/utils.py
+pipelinehub/__init__.py
+pipelinehub/pipeline.py
+pipelinehub/utils.py
+pipelinehub.egg-info/PKG-INFO
+pipelinehub.egg-info/SOURCES.txt
+pipelinehub.egg-info/dependency_links.txt
+pipelinehub.egg-info/not-zip-safe
+pipelinehub.egg-info/requires.txt
+pipelinehub.egg-info/top_level.txt
+tests/test_pipeline.py

pipelinehub-0.1.0/pipelinehub.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pipelinehub-0.1.0/pipelinehub.egg-info/not-zip-safe

@@ -0,0 +1 @@
+

pipelinehub-0.1.0/pipelinehub.egg-info/requires.txt

@@ -0,0 +1,6 @@
+
+[dev]
+pytest>=6.0
+black
+flake8
+mypy

pipelinehub-0.1.0/pipelinehub.egg-info/top_level.txt

@@ -0,0 +1 @@
+pipelinehub

pipelinehub-0.1.0/pyproject.toml

@@ -0,0 +1,54 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pipelinehub"
+version = "0.1.0"
+authors = [
+    {name = "Rahul Paul", email = "paul.rahulxj100@gmail.com"},
+]
+description = "A flexible data pipeline library for custom data processing workflows"
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.7"
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.7",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Scientific/Engineering :: Information Analysis",
+]
+keywords = ["pipeline", "data", "processing", "workflow", "etl"]
+dependencies = []
+
+[project.optional-dependencies]
+dev = ["pytest>=6.0", "black", "flake8", "mypy"]
+
+[project.urls]
+"Homepage" = "https://github.com/rahulxj100/pipelinehub"
+"Bug Reports" = "https://github.com/rahulxj100/pipelinehub/issues"
+"Source" = "https://github.com/rahulxj100/pipelinehub"
+
+[tool.setuptools]
+packages = ["pipelinehub"]
+
+[tool.setuptools.package-dir]
+"" = "."
+
+[tool.black]
+line-length = 88
+target-version = ['py37']
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+python_classes = ["Test*"]
+python_functions = ["test_*"]

pipelinehub-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pipelinehub-0.1.0/setup.py

@@ -0,0 +1,49 @@
+from setuptools import setup, find_packages
+import os
+
+# Read README file
+def read_readme():
+    readme_path = os.path.join(os.path.dirname(__file__), 'README.md')
+    try:
+        with open(readme_path, 'r', encoding='utf-8') as f:
+            return f.read()
+    except FileNotFoundError:
+        return "A flexible data pipeline library for custom data processing workflows"
+
+setup(
+    name="pipelinehub",
+    version="0.1.0",
+    author="Rahul Paul",
+    author_email="paul.rahulxj100@gmail.com",
+    description="A flexible data pipeline library for custom data processing workflows",
+    long_description=read_readme(),
+    long_description_content_type="text/markdown",
+    url="https://github.com/rahulxj100/pipelinehub",
+    project_urls={
+        "Bug Reports": "https://github.com/rahulxj100/pipelinehub/issues",
+        "Source": "https://github.com/rahulxj100/pipelinehub",
+    },
+    packages=find_packages(),
+    classifiers=[
+        "Development Status :: 4 - Beta",
+        "Intended Audience :: Developers",
+        "License :: OSI Approved :: MIT License",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
+        "Topic :: Software Development :: Libraries :: Python Modules",
+        "Topic :: Scientific/Engineering :: Information Analysis",
+    ],
+    keywords=["pipeline", "data", "processing", "workflow", "etl"],
+    python_requires=">=3.7",
+    install_requires=[],
+    extras_require={
+        "dev": ["pytest>=6.0", "black", "flake8", "mypy"],
+    },
+    include_package_data=True,
+    zip_safe=False,
+)

pipelinehub-0.1.0/tests/test_pipeline.py

@@ -0,0 +1,58 @@
+import pytest
+from pipelinehub import DataPipeline
+
+
+class TestDataPipeline:
+    
+    def test_init(self):
+        pipeline = DataPipeline()
+        assert len(pipeline) == 0
+        assert pipeline.data is None
+        
+    def test_init_with_data(self):
+        data = [1, 2, 3]
+        pipeline = DataPipeline(data)
+        assert pipeline.data == data
+        
+    def test_add_step(self):
+        pipeline = DataPipeline()
+        pipeline.add_step(lambda x: x)
+        assert len(pipeline) == 1
+        
+    def test_add_step_invalid(self):
+        pipeline = DataPipeline()
+        with pytest.raises(ValueError):
+            pipeline.add_step("not a function")
+            
+    def test_execute_basic(self):
+        pipeline = DataPipeline()
+        pipeline.add_step(lambda x: [i * 2 for i in x])
+        result = pipeline.execute([1, 2, 3])
+        assert result == [2, 4, 6]
+        
+    def test_execute_no_data(self):
+        pipeline = DataPipeline()
+        pipeline.add_step(lambda x: x)
+        with pytest.raises(ValueError):
+            pipeline.execute()
+            
+    def test_method_chaining(self):
+        result = (DataPipeline()
+                 .add_step(lambda x: [i * 2 for i in x])
+                 .add_step(lambda x: [i + 1 for i in x])
+                 .execute([1, 2, 3]))
+        assert result == [3, 5, 7]
+        
+    def test_clear_steps(self):
+        pipeline = DataPipeline()
+        pipeline.add_step(lambda x: x)
+        pipeline.clear_steps()
+        assert len(pipeline) == 0
+        
+    def test_remove_step(self):
+        pipeline = DataPipeline()
+        pipeline.add_step(lambda x: x, "step1")
+        pipeline.add_step(lambda x: x, "step2")
+        pipeline.remove_step(0)
+        assert len(pipeline) == 1
+        assert pipeline.get_steps() == ["step2"]