pyroid 0.3.0__tar.gz → 0.7.0__tar.gz

{pyroid-0.3.0 → pyroid-0.7.0}/.github/workflows/publish.yml

@@ -4,8 +4,6 @@ on:
   push:
     tags:
       - "v*"
-  repository_dispatch:
-    types: [publish-pypi]
   workflow_dispatch:
     inputs:
       version:
@@ -119,6 +117,49 @@ jobs:
     runs-on: ubuntu-latest
     needs: [linux, windows, macos, sdist]
     steps:
+      - uses: actions/checkout@v4
+      
+      - name: Extract version from tag
+        id: get_version
+        run: |
+          # Extract version from tag (remove 'v' prefix)
+          if [[ $GITHUB_REF == refs/tags/v* ]]; then
+            VERSION=${GITHUB_REF#refs/tags/v}
+            echo "VERSION=$VERSION" >> $GITHUB_OUTPUT
+            echo "Extracted version: $VERSION from tag"
+          elif [[ -n "${{ github.event.inputs.version }}" ]]; then
+            VERSION=${{ github.event.inputs.version }}
+            echo "VERSION=$VERSION" >> $GITHUB_OUTPUT
+            echo "Using manually provided version: $VERSION"
+          else
+            echo "No version found in tag or inputs"
+            exit 1
+          fi
+      
+      - name: Update version in files
+        run: |
+          VERSION="${{ steps.get_version.outputs.VERSION }}"
+          echo "Updating version to $VERSION in all files"
+          
+          # Update pyproject.toml
+          sed -i "s/^version = \"[0-9]*\.[0-9]*\.[0-9]*\"/version = \"$VERSION\"/" pyproject.toml
+          
+          # Update Cargo.toml
+          sed -i "s/^version = \"[0-9]*\.[0-9]*\.[0-9]*\"/version = \"$VERSION\"/" Cargo.toml
+          
+          # Update python/pyroid/__init__.py
+          sed -i "s/__version__ = \"[0-9]*\.[0-9]*\.[0-9]*\"/__version__ = \"$VERSION\"/" python/pyroid/__init__.py
+          
+          # Update setup.py
+          sed -i "s/version=\"[0-9]*\.[0-9]*\.[0-9]*\"/version=\"$VERSION\"/" setup.py
+          
+          # Verify updates
+          echo "Updated versions:"
+          echo "pyproject.toml: $(grep -m 1 "version" pyproject.toml)"
+          echo "Cargo.toml: $(grep -m 1 "version" Cargo.toml)"
+          echo "python/pyroid/__init__.py: $(grep -m 1 "__version__" python/pyroid/__init__.py)"
+          echo "setup.py: $(grep -m 1 "version" setup.py)"
+      
       - uses: actions/download-artifact@v4
         with:
           merge-multiple: true

pyroid-0.7.0/.github/workflows/tests.yml

@@ -0,0 +1,72 @@
+name: Tests
+
+on:
+  push:
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  rust-tests:
+    name: Rust Tests on ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+
+    steps:
+    - uses: actions/checkout@v3
+    
+    - name: Set up Rust
+      uses: actions-rs/toolchain@v1
+      with:
+        toolchain: stable
+        profile: minimal
+        override: true
+    
+    - name: Install Rust dependencies
+      run: |
+        cargo --version
+        
+        # Install additional dependencies if needed
+        if [ "${{ matrix.os }}" = "ubuntu-latest" ]; then
+          sudo apt-get update
+          sudo apt-get install -y libssl-dev
+        fi
+    
+    - name: Run Rust tests
+      run: |
+        # Run all Rust tests with verbose output
+        cargo test --test test_rust_* -- --nocapture
+        
+        # If any test fails, print more detailed information
+        if [ $? -ne 0 ]; then
+          echo "Rust tests failed. Running with backtrace enabled..."
+          RUST_BACKTRACE=1 cargo test --test test_rust_*
+          exit 1
+        fi
+
+  python-tests:
+    name: Python Tests on ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest]
+        python-version: ['3.11']
+
+    steps:
+    - uses: actions/checkout@v3
+    
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v4
+      with:
+        python-version: ${{ matrix.python-version }}
+    
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install pytest numpy
+    
+    - name: Run Python implementation tests
+      run: |
+        # Run only the implementation tests that don't require the Rust extension
+        pytest python/tests/test_*_impl.py -v

{pyroid-0.3.0 → pyroid-0.7.0}/.gitignore

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

{pyroid-0.3.0 → pyroid-0.7.0}/Cargo.lock

@@ -1042,6 +1042,15 @@ version = "1.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "350e9b48cbc6b0e028b0473b114454c6316e57336ee184ceab6e53f72c178b3e"
 
+[[package]]
+name = "ppv-lite86"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9"
+dependencies = [
+ "zerocopy",
+]
+
 [[package]]
 name = "proc-macro2"
 version = "1.0.94"
@@ -1130,8 +1139,9 @@ dependencies = [
 
 [[package]]
 name = "pyroid"
-version = "0.3.0"
+version = "0.7.0"
 dependencies = [
+ "base64",
  "criterion",
  "futures",
  "num_cpus",
@@ -1139,6 +1149,7 @@ dependencies = [
  "pyo3",
  "pyo3-asyncio",
  "pyo3-build-config",
+ "rand",
  "rayon",
  "regex",
  "reqwest",
@@ -1161,6 +1172,36 @@ version = "5.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "74765f6d916ee2faa39bc8e68e4f3ed8949b48cccdac59983d287a7cb71ce9c5"
 
+[[package]]
+name = "rand"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
+dependencies = [
+ "libc",
+ "rand_chacha",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+dependencies = [
+ "ppv-lite86",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+dependencies = [
+ "getrandom 0.2.15",
+]
+
 [[package]]
 name = "rayon"
 version = "1.10.0"
@@ -2051,6 +2092,26 @@ dependencies = [
  "synstructure",
 ]
 
+[[package]]
+name = "zerocopy"
+version = "0.8.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1702d9583232ddb9174e01bb7c15a2ab8fb1bc6f227aa1233858c351a3ba0cb"
+dependencies = [
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.8.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "28a6e20d751156648aa063f3800b706ee209a32c0b4d9f24be3d980b01be55ef"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "zerofrom"
 version = "0.1.6"

{pyroid-0.3.0 → pyroid-0.7.0}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "pyroid"
-version = "0.3.0"
+version = "0.7.0"
 edition = "2021"
 authors = ["Andrew O", "Pyroid Team"]
 description = "High-performance Rust functions for Python"
@@ -58,6 +58,9 @@ num_cpus = "1.16.0"
 
 [dev-dependencies]
 criterion = "0.5.1"
+rand = "0.8.5"
+base64 = "0.21.7"
+regex = "1.10.3"
 
 # Optimize for size in release mode
 [profile.release]

{pyroid-0.3.0 → pyroid-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyroid
-Version: 0.3.0
+Version: 0.7.0
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
@@ -24,6 +24,8 @@ Project-URL: Documentation, https://github.com/ao/pyroid/blob/main/README.md
 
 # 📌 Pyroid: Python on Rust-Powered Steroids
 
+[![Tests](https://github.com/ao/pyroid/actions/workflows/tests.yml/badge.svg)](https://github.com/ao/pyroid/actions/workflows/tests.yml)
+
 ⚡ Blazing fast Rust-powered utilities to eliminate Python's performance bottlenecks.
 
 ## 🔹 Why Pyroid?
@@ -382,6 +384,10 @@ Pyroid offers significant performance improvements over pure Python:
 - **Zero-copy buffers**: Efficient memory management without copying
 - **Parallel processing**: Batch processing with adaptive sizing for optimal performance
 
+For detailed benchmarks and performance comparisons between Pyroid's Rust implementation and Python alternatives, see our [Performance Comparison](docs/performance_comparison.md) document. Our benchmarks show that Pyroid's Rust implementation can be **up to 15,000x faster** than equivalent Python code for certain operations, with performance advantages that scale dramatically with data size.
+
+> **Note**: The Python fallback implementations are provided only for development and testing when the Rust components cannot be built. For production use, the Rust implementation is essential to achieve the performance benefits.
+
 ## Building from Source
 
 To build pyroid from source, you need:
@@ -408,26 +414,53 @@ pip install -e .
 
 For performance-critical applications, consider using the following optimizations:
 
-1. **Unified Runtime**: Initialize the runtime once at the start of your application
+1. **Verify Rust Implementation**: Ensure you're using the high-performance Rust implementation
+   ```bash
+   python check_implementation.py
+   ```
+
+2. **Run Python Tests**: Ensure the Python fallback implementations work correctly
+   ```bash
+   python run_tests.py
+   ```
+
+3. **Run Rust Tests**: Ensure the Rust implementations work correctly
+   ```bash
+   # Run all Rust tests
+   cargo test --test test_rust_*
+   
+   # Or run specific module tests
+   cargo test --test test_rust_core    # Core functionality tests
+   cargo test --test test_rust_math    # Math operations tests
+   cargo test --test test_rust_data    # Data operations tests
+   cargo test --test test_rust_text    # Text operations tests
+   cargo test --test test_rust_io      # I/O operations tests
+   cargo test --test test_rust_image   # Image operations tests
+   cargo test --test test_rust_impl    # ML operations tests
+   ```
+
+   For detailed information about the Rust tests, see [Rust Tests Documentation](docs/rust_tests.md).
+
+2. **Unified Runtime**: Initialize the runtime once at the start of your application
    ```python
    from pyroid.core import runtime
    runtime.init()
    ```
 
-2. **Zero-Copy Buffers**: Use zero-copy buffers for large data transfers
+3. **Zero-Copy Buffers**: Use zero-copy buffers for large data transfers
    ```python
    from pyroid.core import buffer
    zero_copy_buffer = buffer.ZeroCopyBuffer(size)
    ```
 
-3. **Parallel Processing**: Use batch processing for CPU-intensive operations
+4. **Parallel Processing**: Use batch processing for CPU-intensive operations
    ```python
    from pyroid.core import parallel
    processor = parallel.BatchProcessor(adaptive=True)
    results = processor.map(items, process_function)
    ```
 
-4. **Concurrency Control**: Adjust concurrency levels based on your workload
+5. **Concurrency Control**: Adjust concurrency levels based on your workload
    ```python
    client = pyroid.AsyncClient()
    responses = await client.fetch_many(urls, concurrency=optimal_value)

{pyroid-0.3.0 → pyroid-0.7.0}/README.md

@@ -1,5 +1,7 @@
 # 📌 Pyroid: Python on Rust-Powered Steroids
 
+[![Tests](https://github.com/ao/pyroid/actions/workflows/tests.yml/badge.svg)](https://github.com/ao/pyroid/actions/workflows/tests.yml)
+
 ⚡ Blazing fast Rust-powered utilities to eliminate Python's performance bottlenecks.
 
 ## 🔹 Why Pyroid?
@@ -358,6 +360,10 @@ Pyroid offers significant performance improvements over pure Python:
 - **Zero-copy buffers**: Efficient memory management without copying
 - **Parallel processing**: Batch processing with adaptive sizing for optimal performance
 
+For detailed benchmarks and performance comparisons between Pyroid's Rust implementation and Python alternatives, see our [Performance Comparison](docs/performance_comparison.md) document. Our benchmarks show that Pyroid's Rust implementation can be **up to 15,000x faster** than equivalent Python code for certain operations, with performance advantages that scale dramatically with data size.
+
+> **Note**: The Python fallback implementations are provided only for development and testing when the Rust components cannot be built. For production use, the Rust implementation is essential to achieve the performance benefits.
+
 ## Building from Source
 
 To build pyroid from source, you need:
@@ -384,26 +390,53 @@ pip install -e .
 
 For performance-critical applications, consider using the following optimizations:
 
-1. **Unified Runtime**: Initialize the runtime once at the start of your application
+1. **Verify Rust Implementation**: Ensure you're using the high-performance Rust implementation
+   ```bash
+   python check_implementation.py
+   ```
+
+2. **Run Python Tests**: Ensure the Python fallback implementations work correctly
+   ```bash
+   python run_tests.py
+   ```
+
+3. **Run Rust Tests**: Ensure the Rust implementations work correctly
+   ```bash
+   # Run all Rust tests
+   cargo test --test test_rust_*
+   
+   # Or run specific module tests
+   cargo test --test test_rust_core    # Core functionality tests
+   cargo test --test test_rust_math    # Math operations tests
+   cargo test --test test_rust_data    # Data operations tests
+   cargo test --test test_rust_text    # Text operations tests
+   cargo test --test test_rust_io      # I/O operations tests
+   cargo test --test test_rust_image   # Image operations tests
+   cargo test --test test_rust_impl    # ML operations tests
+   ```
+
+   For detailed information about the Rust tests, see [Rust Tests Documentation](docs/rust_tests.md).
+
+2. **Unified Runtime**: Initialize the runtime once at the start of your application
    ```python
    from pyroid.core import runtime
    runtime.init()
    ```
 
-2. **Zero-Copy Buffers**: Use zero-copy buffers for large data transfers
+3. **Zero-Copy Buffers**: Use zero-copy buffers for large data transfers
    ```python
    from pyroid.core import buffer
    zero_copy_buffer = buffer.ZeroCopyBuffer(size)
    ```
 
-3. **Parallel Processing**: Use batch processing for CPU-intensive operations
+4. **Parallel Processing**: Use batch processing for CPU-intensive operations
    ```python
    from pyroid.core import parallel
    processor = parallel.BatchProcessor(adaptive=True)
    results = processor.map(items, process_function)
    ```
 
-4. **Concurrency Control**: Adjust concurrency levels based on your workload
+5. **Concurrency Control**: Adjust concurrency levels based on your workload
    ```python
    client = pyroid.AsyncClient()
    responses = await client.fetch_many(urls, concurrency=optimal_value)

pyroid-0.7.0/ci-requirements.txt

@@ -0,0 +1,4 @@
+# Minimal requirements for CI testing
+pytest>=7.0.0
+numpy>=1.20.0
+maturin>=1.0.0  # For building Rust extensions

pyroid-0.7.0/docs/github_actions_workflow.md

@@ -0,0 +1,65 @@
+# GitHub Actions Workflow Documentation
+
+## Overview
+
+This document describes the GitHub Actions workflow for the Pyroid project. The workflow is designed to automate testing and publishing of the package.
+
+## Workflow Components
+
+### 1. Tests Workflow (tests.yml)
+
+The tests workflow runs automated tests to ensure code quality and functionality.
+
+**Triggers:**
+- Push to any branch
+- Pull requests to main branch
+
+**Jobs:**
+- **rust-tests**: Runs Rust tests on Ubuntu, Windows, and macOS
+- **python-tests**: Runs Python implementation tests on Ubuntu
+
+### 2. Publish Workflow (publish.yml)
+
+The publish workflow builds and publishes the package to PyPI when a new version is tagged.
+
+**Triggers:**
+- Push of tags matching the pattern "v*" (e.g., v0.1.0, v1.2.3)
+- Manual workflow dispatch with version input
+
+**Jobs:**
+- **linux**: Builds wheels for Linux
+- **windows**: Builds wheels for Windows
+- **macos**: Builds wheels for macOS (x86_64 and aarch64)
+- **sdist**: Builds source distribution
+- **release**: Collects all artifacts and publishes to PyPI
+
+**Version Management:**
+- The version is extracted from the tag name (removing the 'v' prefix)
+- The extracted version is used to update version strings in:
+  - pyproject.toml
+  - Cargo.toml
+  - python/pyroid/__init__.py
+  - setup.py
+
+## Release Process
+
+To release a new version:
+
+1. Ensure all changes are committed and pushed to the main branch
+2. Create and push a new tag with the desired version:
+   ```
+   git tag v1.2.3
+   git push origin v1.2.3
+   ```
+3. The publish workflow will automatically:
+   - Extract the version from the tag (1.2.3)
+   - Update version strings in all relevant files
+   - Build wheels for all supported platforms
+   - Publish the package to PyPI
+
+## Benefits of This Approach
+
+1. **Simplicity**: The release process is straightforward and easy to understand
+2. **Manual Control**: Releases are explicitly triggered by creating tags
+3. **Consistency**: The version is always derived from the tag name
+4. **Quality Assurance**: Tests run on every push to ensure code quality

{pyroid-0.3.0 → pyroid-0.7.0}/docs/index.md

@@ -10,6 +10,8 @@ Welcome to the Pyroid documentation! Pyroid is a high-performance Rust-powered l
 | [API Reference](./api/index.md) | Detailed documentation of all Pyroid functions and classes |
 | [Examples](../examples/) | Example code demonstrating various Pyroid features |
 | [Benchmarks](../benchmarks/) | Performance benchmarks comparing Pyroid to other libraries |
+| [Performance Comparison](./performance_comparison.md) | Detailed comparison between Rust and Python implementations |
+| [Rust Tests](./rust_tests.md) | Documentation for the Rust-level tests |
 
 ## 🚀 Quick Start
 
@@ -157,6 +159,38 @@ grayscale_img = img.to_grayscale()
 
 MIT
 
+## 🧪 Testing
+
+Pyroid includes comprehensive test suites at both the Python and Rust levels:
+
+### Python Tests
+
+Run the Python tests to ensure the Python API and fallback implementations work correctly:
+
+```bash
+python run_tests.py
+```
+
+### Rust Tests
+
+Run the Rust tests to ensure the core Rust implementations work correctly:
+
+```bash
+# Run all Rust tests
+cargo test --test test_rust_*
+
+# Or run specific module tests
+cargo test --test test_rust_core    # Core functionality tests
+cargo test --test test_rust_math    # Math operations tests
+cargo test --test test_rust_data    # Data operations tests
+cargo test --test test_rust_text    # Text operations tests
+cargo test --test test_rust_io      # I/O operations tests
+cargo test --test test_rust_image   # Image operations tests
+cargo test --test test_rust_impl    # ML operations tests
+```
+
+For detailed information about the Rust tests, see the [Rust Tests Documentation](./rust_tests.md).
+
 ## 👥 Contributing
 
 Contributions are welcome! Please feel free to submit a Pull Request.