pyroid 0.2.5__tar.gz → 0.2.7__tar.gz

{pyroid-0.2.5 → pyroid-0.2.7}/.gitignore

@@ -4,3 +4,4 @@ target
 *.pyo
 *.pyd
 .venv
+.local

{pyroid-0.2.5 → pyroid-0.2.7}/Cargo.lock

@@ -608,7 +608,7 @@ dependencies = [
 
 [[package]]
 name = "pyroid"
-version = "0.2.5"
+version = "0.2.7"
 dependencies = [
  "criterion",
  "futures",

{pyroid-0.2.5 → pyroid-0.2.7}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "pyroid"
-version = "0.2.5"
+version = "0.2.7"
 edition = "2021"
 authors = ["Andrew O", "Pyroid Team"]
 description = "High-performance Rust functions for Python"

{pyroid-0.2.5 → pyroid-0.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyroid
-Version: 0.2.5
+Version: 0.2.7
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9

{pyroid-0.2.5 → pyroid-0.2.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "pyroid"
-version = "0.2.5"
+version = "0.2.7"
 description = "High-performance Rust functions for Python with a simplified architecture"
 authors = [
     {name = "Pyroid Team", email = "support@ataiva.com"}

{pyroid-0.2.5 → pyroid-0.2.7}/python/pyroid/__init__.py

@@ -25,17 +25,14 @@ Examples:
 """
 
 # Import core functionality
-from .core import (
-    Config,
-    ConfigContext,
-    SharedData,
-    PyroidError,
-    InputError,
-    ComputationError,
-    MemoryError,
-    ConversionError,
-    IoError,
-)
+try:
+    # Try to import directly from the pyroid module
+    from .pyroid import Config, ConfigContext, SharedData
+    from .pyroid import PyroidError, InputError, ComputationError, MemoryError, ConversionError, IoError
+except ImportError:
+    # Fallback to importing from the core module
+    from .core import Config, ConfigContext, SharedData
+    from .core import PyroidError, InputError, ComputationError, MemoryError, ConversionError, IoError
 
 # Import submodules
 from . import core
@@ -64,7 +61,7 @@ def config(**kwargs):
     return ConfigContext(Config(kwargs))
 
 # Version information
-__version__ = "51"
+__version__ = "0.2.5"
 
 __all__ = [
     # Core classes

pyroid-0.2.7/python/pyroid/core/__init__.py

@@ -0,0 +1,78 @@
+"""
+Pyroid Core Module
+=================
+
+This module provides core functionality and shared utilities for Pyroid.
+
+Classes:
+    Config: Configuration management
+    ConfigContext: Context manager for temporary configuration
+    SharedData: Wrapper for shared data
+
+Exceptions:
+    PyroidError: Base exception for all Pyroid errors
+    InputError: Input validation error
+    ComputationError: Computation error
+    MemoryError: Memory error
+    ConversionError: Type conversion error
+    IoError: I/O error
+"""
+
+# Try to import directly from the pyroid module
+try:
+    from ..pyroid import Config, ConfigContext, SharedData
+    from ..pyroid import PyroidError, InputError, ComputationError, MemoryError, ConversionError, IoError
+except ImportError:
+    # Fallback to importing from the core module
+    try:
+        from ..pyroid.core import Config, ConfigContext, SharedData
+        from ..pyroid.core.error import PyroidError, InputError, ComputationError, MemoryError, ConversionError, IoError
+    except ImportError:
+        # If all else fails, create dummy classes for documentation purposes
+        class Config:
+            """Configuration management class (not available)."""
+            pass
+            
+        class ConfigContext:
+            """Context manager for temporary configuration (not available)."""
+            pass
+            
+        class SharedData:
+            """Wrapper for shared data (not available)."""
+            pass
+            
+        class PyroidError(Exception):
+            """Base exception for all Pyroid errors (not available)."""
+            pass
+            
+        class InputError(PyroidError):
+            """Input validation error (not available)."""
+            pass
+            
+        class ComputationError(PyroidError):
+            """Computation error (not available)."""
+            pass
+            
+        class MemoryError(PyroidError):
+            """Memory error (not available)."""
+            pass
+            
+        class ConversionError(PyroidError):
+            """Type conversion error (not available)."""
+            pass
+            
+        class IoError(PyroidError):
+            """I/O error (not available)."""
+            pass
+
+__all__ = [
+    'Config',
+    'ConfigContext',
+    'SharedData',
+    'PyroidError',
+    'InputError',
+    'ComputationError',
+    'MemoryError',
+    'ConversionError',
+    'IoError',
+]

pyroid-0.2.7/python/pyroid/data/__init__.py

@@ -0,0 +1,99 @@
+"""
+Pyroid Data Module
+================
+
+This module provides high-performance data operations.
+
+Classes:
+    DataFrame: DataFrame class for data operations
+
+Functions:
+    filter: Filter a list using a predicate function in parallel
+    map: Map a function over a list in parallel
+    reduce: Reduce a list using a binary function
+    sort: Sort a list in parallel
+    apply: Apply a function to a DataFrame
+    groupby_aggregate: Group by and aggregate a DataFrame
+"""
+
+# Try to import directly from the pyroid module
+try:
+    from ..pyroid import (
+        # DataFrame operations
+        DataFrame,
+        apply,
+        groupby_aggregate,
+        
+        # Collection operations
+        filter,
+        map,
+        reduce,
+        sort,
+    )
+except ImportError:
+    # Fallback to importing from the data module
+    try:
+        from ..pyroid.data import (
+            # DataFrame operations
+            DataFrame,
+            apply,
+            groupby_aggregate,
+            
+            # Collection operations
+            filter,
+            map,
+            reduce,
+            sort,
+        )
+    except ImportError:
+        # If all else fails, create dummy classes and functions for documentation purposes
+        class DataFrame:
+            """DataFrame class for data operations (not available)."""
+            def __init__(self, data=None):
+                self.data = data or {}
+                
+            def __repr__(self):
+                return f"DataFrame({self.data})"
+                
+        def apply(df, func, axis=0):
+            """Apply a function to a DataFrame (not available)."""
+            return df
+            
+        def groupby_aggregate(df, by, agg_dict):
+            """Group by and aggregate a DataFrame (not available)."""
+            return df
+            
+        def filter(items, predicate):
+            """Filter a list using a predicate function (not available)."""
+            return [item for item in items if predicate(item)]
+            
+        def map(items, func):
+            """Map a function over a list (not available)."""
+            return [func(item) for item in items]
+            
+        def reduce(items, func, initial=None):
+            """Reduce a list using a binary function (not available)."""
+            if not items:
+                return initial
+            if initial is None:
+                result = items[0]
+                items = items[1:]
+            else:
+                result = initial
+            for item in items:
+                result = func(result, item)
+            return result
+            
+        def sort(items, key=None, reverse=False):
+            """Sort a list (not available)."""
+            return sorted(items, key=key, reverse=reverse)
+
+__all__ = [
+    'DataFrame',
+    'apply',
+    'groupby_aggregate',
+    'filter',
+    'map',
+    'reduce',
+    'sort',
+]

pyroid-0.2.7/python/pyroid/image/__init__.py

@@ -0,0 +1,16 @@
+"""
+Pyroid Image Module
+================
+
+This module provides high-performance image processing operations.
+
+Submodules:
+    basic: Basic image processing operations
+"""
+
+# Import submodules
+from . import basic
+
+__all__ = [
+    'basic',
+]

pyroid-0.2.7/python/pyroid/image/basic/__init__.py

@@ -0,0 +1,133 @@
+"""
+Pyroid Image Basic Module
+======================
+
+This module provides basic image processing operations.
+
+Functions:
+    create_image: Create a new image
+    from_bytes: Create an image from raw bytes
+    to_grayscale: Convert an image to grayscale
+    resize: Resize an image
+    blur: Apply a blur filter to an image
+    adjust_brightness: Adjust the brightness of an image
+"""
+
+# Try to import directly from the pyroid module
+try:
+    from ...pyroid import (
+        # Image creation
+        create_image,
+        from_bytes,
+        
+        # Image operations
+        Image,
+    )
+except ImportError:
+    # Fallback to importing from the image module
+    try:
+        from ...pyroid.image import (
+            # Image creation
+            create_image,
+            from_bytes,
+            
+            # Image operations
+            Image,
+        )
+    except ImportError:
+        # If all else fails, create dummy classes and functions for documentation purposes
+        class Image:
+            """Image class for image processing operations (not available)."""
+            def __init__(self, width, height, channels):
+                self.width = width
+                self.height = height
+                self.channels = channels
+                self.data = bytearray(width * height * channels)
+                
+            def __repr__(self):
+                return f"Image({self.width}, {self.height}, {self.channels})"
+                
+            def set_pixel(self, x, y, color):
+                """Set a pixel color."""
+                if 0 <= x < self.width and 0 <= y < self.height:
+                    idx = (y * self.width + x) * self.channels
+                    for i, c in enumerate(color[:self.channels]):
+                        self.data[idx + i] = c
+                
+            def get_pixel(self, x, y):
+                """Get a pixel color."""
+                if 0 <= x < self.width and 0 <= y < self.height:
+                    idx = (y * self.width + x) * self.channels
+                    return list(self.data[idx:idx + self.channels])
+                return [0] * self.channels
+                
+            def to_grayscale(self):
+                """Convert to grayscale."""
+                if self.channels == 1:
+                    return self
+                result = Image(self.width, self.height, 1)
+                for y in range(self.height):
+                    for x in range(self.width):
+                        color = self.get_pixel(x, y)
+                        gray = int(0.299 * color[0] + 0.587 * color[1] + 0.114 * color[2])
+                        result.set_pixel(x, y, [gray])
+                return result
+                
+            def resize(self, width, height):
+                """Resize the image."""
+                result = Image(width, height, self.channels)
+                x_ratio = self.width / width
+                y_ratio = self.height / height
+                for y in range(height):
+                    for x in range(width):
+                        src_x = int(x * x_ratio)
+                        src_y = int(y * y_ratio)
+                        result.set_pixel(x, y, self.get_pixel(src_x, src_y))
+                return result
+                
+            def blur(self, radius):
+                """Apply a blur filter."""
+                result = Image(self.width, self.height, self.channels)
+                for y in range(self.height):
+                    for x in range(self.width):
+                        r = min(radius, min(x, self.width - x - 1, y, self.height - y - 1))
+                        count = 0
+                        color_sum = [0] * self.channels
+                        for dy in range(-r, r + 1):
+                            for dx in range(-r, r + 1):
+                                nx, ny = x + dx, y + dy
+                                if 0 <= nx < self.width and 0 <= ny < self.height:
+                                    pixel = self.get_pixel(nx, ny)
+                                    for i in range(self.channels):
+                                        color_sum[i] += pixel[i]
+                                    count += 1
+                        avg_color = [int(c / count) for c in color_sum]
+                        result.set_pixel(x, y, avg_color)
+                return result
+                
+            def adjust_brightness(self, factor):
+                """Adjust the brightness."""
+                result = Image(self.width, self.height, self.channels)
+                for y in range(self.height):
+                    for x in range(self.width):
+                        color = self.get_pixel(x, y)
+                        new_color = [min(255, int(c * factor)) for c in color]
+                        result.set_pixel(x, y, new_color)
+                return result
+                
+        def create_image(width, height, channels):
+            """Create a new image."""
+            return Image(width, height, channels)
+            
+        def from_bytes(data, width, height, channels):
+            """Create an image from raw bytes."""
+            img = Image(width, height, channels)
+            img.data = bytearray(data[:width * height * channels])
+            return img
+
+# Export the Image class and functions
+__all__ = [
+    'Image',
+    'create_image',
+    'from_bytes',
+]

pyroid-0.2.7/python/pyroid/io/__init__.py

@@ -0,0 +1,139 @@
+"""
+Pyroid I/O Module
+===============
+
+This module provides high-performance I/O operations.
+
+Functions:
+    read_file: Read a file
+    write_file: Write a file
+    read_files: Read multiple files in parallel
+    get: HTTP GET request
+    post: HTTP POST request
+    sleep: Async sleep
+    read_file_async: Async read file
+    write_file_async: Async write file
+"""
+
+# Try to import directly from the pyroid module
+try:
+    from ..pyroid import (
+        # File operations
+        read_file,
+        write_file,
+        read_files,
+        
+        # Network operations
+        get,
+        post,
+        
+        # Async operations
+        sleep,
+        read_file_async,
+        write_file_async,
+    )
+except ImportError:
+    # Fallback to importing from the io module
+    try:
+        from ..pyroid.io import (
+            # File operations
+            read_file,
+            write_file,
+            read_files,
+            
+            # Network operations
+            get,
+            post,
+            
+            # Async operations
+            sleep,
+            read_file_async,
+            write_file_async,
+        )
+    except ImportError:
+        # If all else fails, create dummy functions for documentation purposes
+        def read_file(path):
+            """Read a file (not available)."""
+            try:
+                with open(path, 'r') as f:
+                    return f.read()
+            except Exception as e:
+                return f"Error reading file: {e}"
+            
+        def write_file(path, content):
+            """Write a file (not available)."""
+            try:
+                with open(path, 'w') as f:
+                    f.write(content)
+                return True
+            except Exception as e:
+                return f"Error writing file: {e}"
+            
+        def read_files(paths):
+            """Read multiple files in parallel (not available)."""
+            return {path: read_file(path) for path in paths}
+            
+        def get(url, headers=None):
+            """HTTP GET request (not available)."""
+            try:
+                import urllib.request
+                req = urllib.request.Request(url, headers=headers or {})
+                with urllib.request.urlopen(req) as response:
+                    return response.read().decode('utf-8')
+            except Exception as e:
+                return f"Error making GET request: {e}"
+            
+        def post(url, data=None, headers=None):
+            """HTTP POST request (not available)."""
+            try:
+                import urllib.request
+                import json
+                if isinstance(data, dict):
+                    data = json.dumps(data).encode('utf-8')
+                req = urllib.request.Request(url, data=data, headers=headers or {}, method='POST')
+                with urllib.request.urlopen(req) as response:
+                    return response.read().decode('utf-8')
+            except Exception as e:
+                return f"Error making POST request: {e}"
+            
+        async def sleep(seconds):
+            """Async sleep (not available)."""
+            try:
+                import asyncio
+                await asyncio.sleep(seconds)
+            except Exception as e:
+                return f"Error sleeping: {e}"
+            
+        async def read_file_async(path):
+            """Async read file (not available)."""
+            try:
+                import aiofiles
+                async with aiofiles.open(path, 'r') as f:
+                    return await f.read()
+            except ImportError:
+                return read_file(path)
+            except Exception as e:
+                return f"Error reading file asynchronously: {e}"
+            
+        async def write_file_async(path, content):
+            """Async write file (not available)."""
+            try:
+                import aiofiles
+                async with aiofiles.open(path, 'w') as f:
+                    await f.write(content)
+                return True
+            except ImportError:
+                return write_file(path, content)
+            except Exception as e:
+                return f"Error writing file asynchronously: {e}"
+
+__all__ = [
+    'read_file',
+    'write_file',
+    'read_files',
+    'get',
+    'post',
+    'sleep',
+    'read_file_async',
+    'write_file_async',
+]

pyroid-0.2.7/python/pyroid/math/__init__.py

@@ -0,0 +1,141 @@
+"""
+Pyroid Math Module
+================
+
+This module provides high-performance mathematical operations.
+
+Classes:
+    Vector: Vector class for mathematical operations
+    Matrix: Matrix class for mathematical operations
+
+Functions:
+    sum: Sum a list of numbers in parallel
+    multiply: Matrix multiplication function
+    mean: Calculate the mean of a list of numbers
+    median: Calculate the median of a list of numbers
+    std: Calculate the standard deviation of a list of numbers
+    variance: Calculate the variance of a list of numbers
+    correlation: Calculate the correlation coefficient between two lists of numbers
+    describe: Calculate descriptive statistics for a list of numbers
+"""
+
+# Try to import directly from the pyroid module
+try:
+    from ..pyroid import (
+        # Vector operations
+        Vector,
+        sum,
+        
+        # Matrix operations
+        Matrix,
+        multiply,
+        
+        # Statistical operations
+        mean,
+        median,
+        std,
+        variance,
+        correlation,
+        describe,
+    )
+except ImportError:
+    # Fallback to importing from the math module
+    try:
+        from ..pyroid.math import (
+            # Vector operations
+            Vector,
+            sum,
+            
+            # Matrix operations
+            Matrix,
+            multiply,
+            
+            # Statistical operations
+            mean,
+            median,
+            std,
+            variance,
+            correlation,
+            describe,
+        )
+    except ImportError:
+        # If all else fails, create dummy classes for documentation purposes
+        class Vector:
+            """Vector class for mathematical operations (not available)."""
+            def __init__(self, values):
+                self.values = values
+                
+            def __add__(self, other):
+                return self
+                
+            def dot(self, other):
+                return 0
+                
+        class Matrix:
+            """Matrix class for mathematical operations (not available)."""
+            def __init__(self, values):
+                self.values = values
+                
+            def __mul__(self, other):
+                return self
+                
+        # Dummy functions
+        def sum(values):
+            """Sum a list of numbers (not available)."""
+            return 0
+            
+        def multiply(a, b):
+            """Matrix multiplication function (not available)."""
+            return [[0]]
+            
+        def mean(values):
+            """Calculate the mean of a list of numbers (not available)."""
+            return 0
+            
+        def median(values):
+            """Calculate the median of a list of numbers (not available)."""
+            return 0
+            
+        def std(values):
+            """Calculate the standard deviation of a list of numbers (not available)."""
+            return 0
+            
+        def variance(values):
+            """Calculate the variance of a list of numbers (not available)."""
+            return 0
+            
+        def correlation(x, y):
+            """Calculate the correlation coefficient between two lists of numbers (not available)."""
+            return 0
+            
+        def describe(values):
+            """Calculate descriptive statistics for a list of numbers (not available)."""
+            return {}
+
+# Import submodules
+try:
+    from . import stats
+except ImportError:
+    # Create a dummy stats module if it's not available
+    import types
+    stats = types.ModuleType('stats')
+    stats.mean = mean
+    stats.median = median
+    stats.calc_std = std
+    stats.variance = variance
+    stats.correlation = correlation
+    stats.describe = describe
+
+__all__ = [
+    'Vector',
+    'sum',
+    'Matrix',
+    'multiply',
+    'mean',
+    'median',
+    'std',
+    'variance',
+    'correlation',
+    'describe',
+    'stats',
+]