pyarallel 0.1.2__tar.gz → 0.1.3__tar.gz

{pyarallel-0.1.2 → pyarallel-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyarallel
-Version: 0.1.2
+Version: 0.1.3
 Summary: A powerful parallel execution library for Python
 Project-URL: Homepage, https://github.com/oneryalcin/pyarallel
 Project-URL: Repository, https://github.com/oneryalcin/pyarallel.git
@@ -98,6 +98,56 @@ def analyze_text(text: str) -> dict:
     return text_analysis(text)
 ```
 
+## Usage Examples
+
+### Basic Function
+```python
+from pyarallel import parallel
+
+@parallel
+def process_item(x):
+    return x * 2
+
+results = process_item([1, 2, 3])  # [2, 4, 6]
+```
+
+### Instance Methods
+```python
+class DataProcessor:
+    def __init__(self, multiplier):
+        self.multiplier = multiplier
+    
+    @parallel
+    def process(self, x):
+        return x * self.multiplier
+
+processor = DataProcessor(3)
+results = processor.process([1, 2, 3])  # [3, 6, 9]
+```
+
+### Class Methods
+```python
+class StringFormatter:
+    @classmethod
+    @parallel
+    def format_all(cls, items):
+        return [f"Formatted-{item}" for item in items]
+
+results = StringFormatter.format_all(['a', 'b', 'c'])
+# ['Formatted-a', 'Formatted-b', 'Formatted-c']
+```
+
+### Static Methods
+```python
+class MathUtils:
+    @staticmethod
+    @parallel
+    def square_all(numbers):
+        return [n**2 for n in numbers]
+
+results = MathUtils.square_all([1, 2, 3])  # [1, 4, 9]
+```
+
 ## Advanced Usage
 
 ### Rate Limiting

{pyarallel-0.1.2 → pyarallel-0.1.3}/README.md

@@ -59,6 +59,56 @@ def analyze_text(text: str) -> dict:
     return text_analysis(text)
 ```
 
+## Usage Examples
+
+### Basic Function
+```python
+from pyarallel import parallel
+
+@parallel
+def process_item(x):
+    return x * 2
+
+results = process_item([1, 2, 3])  # [2, 4, 6]
+```
+
+### Instance Methods
+```python
+class DataProcessor:
+    def __init__(self, multiplier):
+        self.multiplier = multiplier
+    
+    @parallel
+    def process(self, x):
+        return x * self.multiplier
+
+processor = DataProcessor(3)
+results = processor.process([1, 2, 3])  # [3, 6, 9]
+```
+
+### Class Methods
+```python
+class StringFormatter:
+    @classmethod
+    @parallel
+    def format_all(cls, items):
+        return [f"Formatted-{item}" for item in items]
+
+results = StringFormatter.format_all(['a', 'b', 'c'])
+# ['Formatted-a', 'Formatted-b', 'Formatted-c']
+```
+
+### Static Methods
+```python
+class MathUtils:
+    @staticmethod
+    @parallel
+    def square_all(numbers):
+        return [n**2 for n in numbers]
+
+results = MathUtils.square_all([1, 2, 3])  # [1, 4, 9]
+```
+
 ## Advanced Usage
 
 ### Rate Limiting

{pyarallel-0.1.2 → pyarallel-0.1.3}/TASKS.md

@@ -72,11 +72,11 @@ def test_runtime_warnings():
     """Warnings for problematic configs"""
 ```
 
-## 5. Documentation [ ]
-- [ ] Add configuration section to README
-- [ ] Document all environment variables
-- [ ] Add configuration examples
-- [ ] Document best practices
+## 5. Documentation [✅]
+- [✅] Add configuration section to README
+- [✅] Document all environment variables
+- [✅] Add configuration examples
+- [✅] Document best practices
 
 ## Configuration Schema
 ```python
@@ -121,3 +121,33 @@ PYARALLEL_SENTRY_DSN=https://...
 - 🚧 In progress
 - ❌ Blocked
 - [ ] Not started
+
+## Feature: Enhanced Decorator Ergonomics
+
+Implement first-class support for decorating instance, static, and class methods with `@parallel`.
+
+- [✅] **1. Analyze Core Decorator Logic**
+    - [✅] Examine `@parallel` implementation in `pyarallel/core.py`.
+    - [✅] Understand current argument inspection and `executor.submit` usage.
+- [✅] **2. Modify Argument Handling**
+    - [✅] Update the `wrapper` function to detect method type (instance, static, class).
+    - [✅] Correctly identify the iterable/item argument based on method type (using `inspect` or signature analysis).
+- [✅] **3. Adapt Executor Submission**
+    - [✅] Ensure `self`/`cls` are passed correctly to `executor.submit` for instance/class methods.
+    - [✅] Preserve other arguments (`*args`, `**kwargs`).
+- [✅] **4. Implement Comprehensive Tests**
+    - [✅] Add tests for instance methods (`test_instance_method_parallel`).
+    - [✅] Add tests for static methods (`test_static_method_parallel`).
+    - [✅] Add tests for class methods (`test_class_method_parallel`).
+    - [✅] Include tests for single item and list inputs.
+    - [✅] Test methods with additional arguments.
+    - [✅] Ensure no regressions for regular functions.
+- [✅] **5. Update Documentation**
+    - [✅] Update `README.md` and `docs/index.md` with clear examples for each method type.
+- [✅] **6. Code Review and Refinement**
+    - [✅] Review implementation, tests, and documentation.
+    - [✅] Ensure robustness, adherence to standards, and clarity.
+- [✅] **7. Add Type Hints**
+    - [✅] Add type hints to the `@parallel` decorator and inner `wrapper` in `pyarallel/core.py` for better IDE support.
+
+## Future Enhancements / Ideas

{pyarallel-0.1.2 → pyarallel-0.1.3}/docs/development/roadmap.md

@@ -56,6 +56,10 @@ Some of the features we're planning to add in the future:
   - Resource quotas per task
 
 ### Developer Experience
+- **Enhanced Decorator Ergonomics**
+  - First-class, documented support for `@parallel` on instance methods, static methods, and class methods.
+  - Automatic handling of `self` and `cls` arguments.
+  - Clear examples and best practices for OOP usage.
 - **CLI Tools**
   - Task monitoring dashboard
   - Performance profiling

{pyarallel-0.1.2 → pyarallel-0.1.3}/docs/index.md

@@ -36,6 +36,46 @@ urls = ["http://api1.com", "http://api2.com"]
 results = fetch_url(urls)
 ```
 
+## Advanced Usage
+
+### Method Support
+
+The `@parallel` decorator works seamlessly with:
+- Regular functions
+- Instance methods (preserves `self`)
+- Class methods (preserves `cls`)
+- Static methods
+
+#### Instance Method Example
+```python
+class DataTransformer:
+    def __init__(self, base):
+        self.base = base
+    
+    @parallel
+    def transform(self, items):
+        return [self.base + x for x in items]
+```
+
+#### Class Method Example
+```python
+class Logger:
+    log_prefix = "APP"
+    
+    @classmethod
+    @parallel
+    def log_all(cls, messages):
+        return [f"{cls.log_prefix}: {msg}" for msg in messages]
+```
+
+### Argument Handling
+
+The decorator intelligently handles:
+- Positional arguments
+- Keyword arguments
+- Mixed argument types
+- Both single items and iterables
+
 ## Installation
 
 ```bash

{pyarallel-0.1.2 → pyarallel-0.1.3}/pyarallel/__init__.py

@@ -1,4 +1,4 @@
-from .core import parallel, RateLimit
+from .core import RateLimit, parallel
 
 __version__ = "0.1.0"
 __all__ = ["parallel", "RateLimit"]
@@ -7,4 +7,4 @@ __doc__ = f"""
 pyarallel v{__version__}
 
 Simple parallel processing framework for Python.
-"""
+"""

{pyarallel-0.1.2 → pyarallel-0.1.3}/pyarallel/config.py

@@ -7,49 +7,39 @@ with support for loading configurations from different sources and thread-safe o
 from pathlib import Path
 from typing import Any, Dict, Optional, Union
 
-from pydantic import BaseModel, Field, ConfigDict
+from pydantic import BaseModel, ConfigDict, Field
 
 
 class ExecutionConfig(BaseModel):
     """Execution configuration settings."""
+
     max_workers: int = Field(
-        default=4,
-        description="Maximum number of worker processes/threads",
-        ge=1
+        default=4, description="Maximum number of worker processes/threads", ge=1
     )
     timeout: float = Field(
         default=30.0,
         description="Default timeout for parallel operations in seconds",
-        ge=0
+        ge=0,
     )
     default_max_workers: int = Field(
-        default=4,
-        description="Default number of workers for parallel operations",
-        ge=1
+        default=4, description="Default number of workers for parallel operations", ge=1
     )
     default_executor_type: str = Field(
-        default="thread",
-        description="Default executor type (thread or process)"
+        default="thread", description="Default executor type (thread or process)"
     )
     default_batch_size: int = Field(
-        default=10,
-        description="Default batch size for parallel operations",
-        ge=1
+        default=10, description="Default batch size for parallel operations", ge=1
     )
-    
+
     model_config = ConfigDict(extra="allow")  # Allow dynamic fields
 
+
 class RateLimitingConfig(BaseModel):
     """Rate limiting configuration settings."""
-    rate: int = Field(
-        default=1000,
-        description="Rate limit per interval",
-        ge=0
-    )
-    interval: str = Field(
-        default="minute",
-        description="Rate limit interval"
-    )
+
+    rate: int = Field(default=1000, description="Rate limit per interval", ge=0)
+    interval: str = Field(default="minute", description="Rate limit interval")
+
 
 class PyarallelConfig(BaseModel):
     """Base configuration class for pyarallel.
@@ -60,57 +50,44 @@ class PyarallelConfig(BaseModel):
 
     # Execution settings
     max_workers: int = Field(
-        default=4,
-        description="Maximum number of worker processes/threads",
-        ge=1
+        default=4, description="Maximum number of worker processes/threads", ge=1
     )
     timeout: float = Field(
         default=30.0,
         description="Default timeout for parallel operations in seconds",
-        ge=0
+        ge=0,
     )
     execution: Optional[ExecutionConfig] = Field(
-        default=None,
-        description="Nested execution settings"
+        default=None, description="Nested execution settings"
     )
 
     # Rate limiting settings
     rate_limiting: Optional[RateLimitingConfig] = Field(
-        default=None,
-        description="Rate limiting settings"
+        default=None, description="Rate limiting settings"
     )
 
     # Error handling settings
     error_handling: Dict[str, Any] = Field(
         default_factory=lambda: {"retry_count": 3},
-        description="Error handling settings"
+        description="Error handling settings",
     )
 
     # Monitoring settings
     monitoring: Dict[str, Any] = Field(
-        default_factory=lambda: {"enabled": False},
-        description="Monitoring settings"
+        default_factory=lambda: {"enabled": False}, description="Monitoring settings"
     )
 
     # Resource management
     memory_limit: Optional[int] = Field(
-        default=None,
-        description="Memory limit per worker in bytes, None for no limit"
+        default=None, description="Memory limit per worker in bytes, None for no limit"
     )
     cpu_affinity: bool = Field(
-        default=False,
-        description="Enable CPU affinity for workers"
+        default=False, description="Enable CPU affinity for workers"
     )
 
     # Logging and debugging
-    debug: bool = Field(
-        default=False,
-        description="Enable debug mode"
-    )
-    log_level: str = Field(
-        default="INFO",
-        description="Logging level"
-    )
+    debug: bool = Field(default=False, description="Enable debug mode")
+    log_level: str = Field(default="INFO", description="Logging level")
 
     @classmethod
     def from_dict(cls, config_dict: Dict[str, Any]) -> "PyarallelConfig":
@@ -148,18 +125,23 @@ class PyarallelConfig(BaseModel):
         # Load based on file extension
         if config_path.suffix == ".json":
             import json
+
             with open(config_path) as f:
                 config_dict = json.load(f)
         elif config_path.suffix in (".yml", ".yaml"):
             import yaml
+
             with open(config_path) as f:
                 config_dict = yaml.safe_load(f)
         elif config_path.suffix == ".toml":
             import toml
+
             with open(config_path) as f:
                 config_dict = toml.load(f)
         else:
-            raise ValueError(f"Unsupported configuration file format: {config_path.suffix}")
+            raise ValueError(
+                f"Unsupported configuration file format: {config_path.suffix}"
+            )
 
         return cls.from_dict(config_dict)
 
@@ -169,4 +151,4 @@ class PyarallelConfig(BaseModel):
         Returns:
             Dictionary representation of the configuration
         """
-        return self.model_dump()
+        return self.model_dump()

{pyarallel-0.1.2 → pyarallel-0.1.3}/pyarallel/config_manager.py

@@ -13,7 +13,7 @@ from .env_config import load_env_vars
 
 logger = logging.getLogger(__name__)
 
-T = TypeVar('T', bound='ConfigManager')
+T = TypeVar("T", bound="ConfigManager")
 
 
 class ConfigManager:
@@ -22,6 +22,7 @@ class ConfigManager:
     This class ensures thread-safe access to configuration settings and provides
     methods for updating and retrieving configuration values.
     """
+
     _instance: Optional[T] = None
     _lock: RLock = RLock()
     _config: Optional[PyarallelConfig] = None
@@ -34,18 +35,23 @@ class ConfigManager:
                     # Initialize with default config
                     config_dict = PyarallelConfig().model_dump()
                     logger.debug(f"Default config: {config_dict}")
-                    
+
                     # Load and apply environment variables
                     env_config = load_env_vars()
                     logger.debug(f"Loaded environment config: {env_config}")
-                    
+
                     # Update config with environment variables
                     if env_config:
                         logger.debug("Updating config with environment variables")
-                        config_dict = {**config_dict, **env_config}  # Use dictionary unpacking for proper update
+                        config_dict = {
+                            **config_dict,
+                            **env_config,
+                        }  # Use dictionary unpacking for proper update
                         logger.debug(f"Updated config: {config_dict}")
-                    
-                    cls._instance._config = PyarallelConfig(**config_dict)  # Use direct instantiation
+
+                    cls._instance._config = PyarallelConfig(
+                        **config_dict
+                    )  # Use direct instantiation
                     logger.debug(f"Final config: {cls._instance._config}")
         return cls._instance
 
@@ -79,18 +85,20 @@ class ConfigManager:
             current_config = self._config.model_dump()
             logger.debug(f"Current config before update: {current_config}")
             logger.debug(f"Incoming updates: {updates}")
-            
+
             # Validate max_workers before merging
             if "max_workers" in updates and updates["max_workers"] < 1:
                 updates["max_workers"] = 1
-            
+
             # Use deep merge for nested updates
             merged_config = self._deep_merge(current_config, updates)
             logger.debug(f"Merged config: {merged_config}")
             self._config = PyarallelConfig.from_dict(merged_config)
             logger.debug(f"Final config after update: {self._config}")
 
-    def _deep_merge(self, base: Dict[str, Any], updates: Dict[str, Any]) -> Dict[str, Any]:
+    def _deep_merge(
+        self, base: Dict[str, Any], updates: Dict[str, Any]
+    ) -> Dict[str, Any]:
         """Recursively merge two configuration dictionaries with special handling for execution settings.
 
         This method implements a specialized merge strategy for configuration dictionaries that:
@@ -123,13 +131,13 @@ class ConfigManager:
         logger.debug(f"Deep merging - Base: {base}")
         logger.debug(f"Deep merging - Updates: {updates}")
         result = base.copy()
-        
+
         # Initialize critical nested structures
         self._ensure_critical_structures(result)
-        
+
         for key, value in updates.items():
             logger.debug(f"Processing key: {key}, value: {value}")
-            
+
             if self._is_execution_update(key, value):
                 self._handle_execution_settings(result, value)
             elif self._is_nested_dict_update(key, value, result):
@@ -137,11 +145,11 @@ class ConfigManager:
             else:
                 result[key] = value
                 logger.debug(f"Direct value assignment for key: {key}")
-            
+
             # Re-ensure critical structures after each update
             self._ensure_critical_structures(result)
             logger.debug(f"Current result after processing {key}: {result}")
-        
+
         return result
 
     def _ensure_critical_structures(self, config: Dict[str, Any]) -> None:
@@ -151,15 +159,17 @@ class ConfigManager:
             config: The configuration dictionary to initialize
         """
         critical_structures = {
-            'execution': {},
-            'rate_limiting': {},
-            'error_handling': {'retry_count': 3},
-            'monitoring': {'enabled': False}
+            "execution": {},
+            "rate_limiting": {},
+            "error_handling": {"retry_count": 3},
+            "monitoring": {"enabled": False},
         }
         for structure, default_value in critical_structures.items():
             if structure not in config or config[structure] is None:
                 config[structure] = default_value.copy()
-                logger.debug(f"Initialized {structure} structure with defaults: {default_value}")
+                logger.debug(
+                    f"Initialized {structure} structure with defaults: {default_value}"
+                )
 
     def _is_execution_update(self, key: str, value: Any) -> bool:
         """Check if the update is for execution settings.
@@ -173,7 +183,9 @@ class ConfigManager:
         """
         return key == "execution" and isinstance(value, dict)
 
-    def _is_nested_dict_update(self, key: str, value: Any, base: Dict[str, Any]) -> bool:
+    def _is_nested_dict_update(
+        self, key: str, value: Any, base: Dict[str, Any]
+    ) -> bool:
         """Check if the update is for a nested dictionary.
 
         Args:
@@ -184,11 +196,11 @@ class ConfigManager:
         Returns:
             bool: True if this is a nested dictionary update
         """
-        return (key in base and 
-                isinstance(base[key], dict) and 
-                isinstance(value, dict))
+        return key in base and isinstance(base[key], dict) and isinstance(value, dict)
 
-    def _handle_execution_settings(self, config: Dict[str, Any], execution_settings: Dict[str, Any]) -> None:
+    def _handle_execution_settings(
+        self, config: Dict[str, Any], execution_settings: Dict[str, Any]
+    ) -> None:
         """Handle special case of execution settings update.
 
         This method maintains both top-level and nested execution settings
@@ -201,19 +213,23 @@ class ConfigManager:
         # Update top-level settings for backward compatibility
         if "max_workers" in execution_settings:
             config["max_workers"] = execution_settings["max_workers"]
-            logger.debug(f"Set top-level max_workers: {execution_settings['max_workers']}")
+            logger.debug(
+                f"Set top-level max_workers: {execution_settings['max_workers']}"
+            )
         if "timeout" in execution_settings:
             config["timeout"] = execution_settings["timeout"]
             logger.debug(f"Set top-level timeout: {execution_settings['timeout']}")
-        
+
         # Initialize execution settings if None
         if config["execution"] is None:
             config["execution"] = {}
             logger.debug("Initialized empty execution settings")
-        
+
         # Merge with existing execution settings
         config["execution"] = {**config["execution"], **execution_settings}
-        logger.debug(f"Merged execution settings in nested structure: {config['execution']}")
+        logger.debug(
+            f"Merged execution settings in nested structure: {config['execution']}"
+        )
 
     def reset(self) -> None:
         """Reset the configuration to default values.
@@ -233,56 +249,66 @@ class ConfigManager:
             value: Value to set
         """
         with self._lock:
-            parts = key.split('.')
+            parts = key.split(".")
             current = self._config.model_dump()
             target = current
             logger.debug(f"Setting config value - Key: {key}, Value: {value}")
             logger.debug(f"Current config state: {current}")
-            
+
             # Handle execution settings at top level
-            if parts[0] == 'execution' and len(parts) == 2:
-                if parts[1] in ['max_workers', 'timeout']:
+            if parts[0] == "execution" and len(parts) == 2:
+                if parts[1] in ["max_workers", "timeout"]:
                     target[parts[1]] = value
-                    logger.debug(f"Setting top-level execution parameter: {parts[1]} = {value}")
+                    logger.debug(
+                        f"Setting top-level execution parameter: {parts[1]} = {value}"
+                    )
                 else:
                     # Create execution dictionary if needed
-                    if 'execution' not in target:
-                        target['execution'] = {}
-                    target['execution'][parts[1]] = value
-                    logger.debug(f"Setting nested execution parameter: {parts[1]} = {value}")
+                    if "execution" not in target:
+                        target["execution"] = {}
+                    target["execution"][parts[1]] = value
+                    logger.debug(
+                        f"Setting nested execution parameter: {parts[1]} = {value}"
+                    )
             else:
                 # Initialize nested configuration objects if needed
-                if parts[0] == 'rate_limiting' and target['rate_limiting'] is None:
-                    target['rate_limiting'] = {'rate': 1000, 'interval': 'minute'}
-                    logger.debug(f"Initialized rate_limiting config: {target['rate_limiting']}")
+                if parts[0] == "rate_limiting" and target["rate_limiting"] is None:
+                    target["rate_limiting"] = {"rate": 1000, "interval": "minute"}
+                    logger.debug(
+                        f"Initialized rate_limiting config: {target['rate_limiting']}"
+                    )
 
                 # Navigate to the nested location
                 for part in parts[:-1]:
                     if part not in target:
                         target[part] = {}
                     target = target[part]
-                    logger.debug(f"Navigating to nested key: {part}, Current target: {target}")
+                    logger.debug(
+                        f"Navigating to nested key: {part}, Current target: {target}"
+                    )
 
                 # Set the value
                 target[parts[-1]] = value
                 logger.debug(f"Set final value at {parts[-1]}: {value}")
-            
+
             logger.debug(f"Updated config state: {current}")
             self._config = PyarallelConfig.from_dict(current)
             logger.debug(f"Final config after update: {self._config}")
 
     def get(self, key: str, default: Any = None) -> Any:
-        parts = key.split('.')
+        parts = key.split(".")
         current = self._config.model_dump()
         logger.debug(f"Getting config value - Key: {key}")
         logger.debug(f"Current config state: {current}")
 
         # Handle execution settings specially
-        if parts[0] == 'execution':
-            if current['execution'] is None:
+        if parts[0] == "execution":
+            if current["execution"] is None:
                 # Check if the value exists at top level
-                if len(parts) == 2 and parts[1] in ['max_workers', 'timeout']:
-                    logger.debug(f"Retrieving top-level {parts[1]} value: {current[parts[1]]}")
+                if len(parts) == 2 and parts[1] in ["max_workers", "timeout"]:
+                    logger.debug(
+                        f"Retrieving top-level {parts[1]} value: {current[parts[1]]}"
+                    )
                     return current[parts[1]]
                 logger.debug("Execution config is None, returning default")
                 return default
@@ -339,4 +365,4 @@ class ConfigManager:
         """
         with self._lock:
             updates = {"monitoring": kwargs}
-            self.update_config(updates)
+            self.update_config(updates)