r4py 4.6.2.1__tar.gz

r4py-4.6.2.1/.github/workflows/ci.yml

@@ -0,0 +1,27 @@
+name: Python
+
+on:
+  push:
+  pull_request:
+
+permissions:
+  contents: read
+
+jobs:
+  check:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python: ["3.10", "3.14"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v6
+        with:
+          python-version: ${{ matrix.python }}
+          enable-cache: true
+      - run: uv sync --locked --no-install-project
+      - run: uv run --no-sync ruff check .
+      - run: uv run --no-sync ruff format --check .
+      - run: uv run --no-sync pyright
+      - run: uv run --no-sync pytest -m "not runtime"
+

r4py-4.6.2.1/.github/workflows/wheels.yml

@@ -0,0 +1,181 @@
+name: Wheels
+
+on:
+  workflow_dispatch:
+    inputs:
+      publish:
+        description: Publish to PyPI after configuring trusted publishing (run on a release tag)
+        type: boolean
+        default: false
+  push:
+    tags: ["v*"]
+  pull_request:
+
+permissions:
+  contents: read
+
+jobs:
+  source:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v6
+        with:
+          python-version: "3.12"
+      - name: Check release tag
+        run: |
+          VERSION=$(python -c 'import runpy; print(runpy.run_path("src/r4py/__init__.py")["__version__"])')
+          if [ "$GITHUB_REF_TYPE" = tag ]; then
+            test "$GITHUB_REF_NAME" = "v$VERSION"
+          fi
+      - run: uv build --sdist
+      - uses: actions/upload-artifact@v4
+        with:
+          name: source
+          path: dist/*.tar.gz
+
+  linux:
+    runs-on: ${{ matrix.runner }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - runner: ubuntu-24.04
+            arch: x86_64
+          - runner: ubuntu-24.04-arm
+            arch: aarch64
+    steps:
+      - uses: actions/checkout@v4
+      - name: Build and repair
+        run: |
+          docker run --rm -v "$PWD:/work" -w /work \
+            quay.io/pypa/manylinux_2_28_${{ matrix.arch }} \
+            bash -euxc '
+              dnf install -y libcurl-devel bzip2-devel xz-devel zlib-devel \
+                pcre2-devel libicu-devel readline-devel cairo-devel \
+                libpng-devel libjpeg-turbo-devel libtiff-devel
+              PY=/opt/python/cp312-cp312/bin/python
+              "$PY" -m pip install build
+              "$PY" build_r_runtime.py --jobs 4
+              cp -a /usr/share/licenses src/r4py/r-runtime/dependency-licenses
+              rpm -qa --qf "%{NAME} %{VERSION}-%{RELEASE} %{SOURCERPM}\n" \
+                > src/r4py/r-runtime/dependency-sources.txt
+              "$PY" -m build --wheel
+              AUDITWHEEL_LD_LIBRARY_PATH=/work/src/r4py/r-runtime/lib \
+                auditwheel repair --strip --plat manylinux_2_28_${{ matrix.arch }} \
+                -w wheelhouse dist/*.whl
+            '
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - name: Test installed wheel
+        run: python tests/smoke_wheel.py wheelhouse/*.whl
+      - uses: actions/upload-artifact@v4
+        with:
+          name: wheels-linux-${{ matrix.arch }}
+          path: wheelhouse/*.whl
+
+  native:
+    runs-on: ${{ matrix.runner }}
+    env:
+      MACOSX_DEPLOYMENT_TARGET: "15.0"
+    defaults:
+      run:
+        shell: bash
+    strategy:
+      fail-fast: false
+      matrix:
+        runner: [macos-15, macos-15-intel, windows-latest]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - run: python -m pip install build
+      - name: Select R version
+        id: r
+        run: |
+          VERSION=$(python -c 'import runpy; print(".".join(runpy.run_path("src/r4py/__init__.py")["__version__"].split(".")[:3]))')
+          echo "version=$VERSION" >> "$GITHUB_OUTPUT"
+      - uses: r-lib/actions/setup-r@v2
+        if: runner.os == 'Windows'
+        with:
+          r-version: ${{ steps.r.outputs.version }}
+          use-public-rspm: false
+      - name: Copy Windows R
+        if: runner.os == 'Windows'
+        run: |
+          R_HOME=$(Rscript --vanilla -e 'cat(R.home())')
+          python build_r_runtime.py --runtime "$R_HOME"
+      - name: Build macOS R
+        if: runner.os == 'macOS'
+        run: |
+          brew install gcc@14 pkgconf curl pcre2 xz icu4c readline cairo \
+            libpng jpeg-turbo libtiff
+          FC="$(brew --prefix gcc@14)/bin/gfortran-14"
+          test -x "$FC"
+          PKG_CONFIG_PATH="$(brew --prefix)/lib/pkgconfig:$(brew --prefix curl)/lib/pkgconfig:$(brew --prefix icu4c)/lib/pkgconfig:$(brew --prefix readline)/lib/pkgconfig"
+          CPPFLAGS="-I$(brew --prefix)/include -I$(brew --prefix curl)/include -I$(brew --prefix readline)/include -I$(brew --prefix icu4c)/include"
+          LDFLAGS="-L$(brew --prefix)/lib -L$(brew --prefix curl)/lib -L$(brew --prefix readline)/lib -L$(brew --prefix icu4c)/lib"
+          export FC PKG_CONFIG_PATH CPPFLAGS LDFLAGS
+          python build_r_runtime.py --jobs 4
+          brew info --json=v2 --installed \
+            > src/r4py/r-runtime/dependency-sources.json
+          CELLAR=$(brew --cellar)
+          (cd "$CELLAR" && find . -type f \
+            \( -iname 'license*' -o -iname 'copying*' -o -iname 'copyright*' \) \
+            -print0) | tar -C "$CELLAR" --null -T - \
+              -cf src/r4py/r-runtime/dependency-licenses.tar
+      - name: Build wheel
+        run: python -m build --wheel
+      - name: Repair macOS wheel
+        if: runner.os == 'macOS'
+        run: |
+          python -m pip install delocate
+          DYLD_LIBRARY_PATH="$PWD/src/r4py/r-runtime/lib" python - <<'PY'
+          import os
+          import platform
+          from pathlib import Path
+          from delocate.delocating import delocate_wheel
+          from packaging.version import Version
+
+          output = Path("wheelhouse")
+          output.mkdir(exist_ok=True)
+          for wheel in Path("dist").glob("*.whl"):
+              delocate_wheel(
+                  str(wheel),
+                  str(output / wheel.name),
+                  lib_filt_func=lambda path: not path.endswith(".class"),
+                  require_archs=[platform.machine()],
+                  require_target_macos_version=Version(os.environ["MACOSX_DEPLOYMENT_TARGET"]),
+              )
+          PY
+      - name: Stage Windows wheel
+        if: runner.os == 'Windows'
+        run: mkdir -p wheelhouse && cp dist/*.whl wheelhouse/
+      - name: Test installed wheel
+        run: python tests/smoke_wheel.py wheelhouse/*.whl
+      - uses: actions/upload-artifact@v4
+        with:
+          name: wheels-${{ matrix.runner }}
+          path: wheelhouse/*.whl
+
+  publish:
+    if: github.event_name == 'workflow_dispatch' && inputs.publish && startsWith(github.ref, 'refs/tags/v')
+    needs: [source, linux, native]
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: source
+          path: dist
+      - uses: actions/download-artifact@v4
+        with:
+          pattern: wheels-*
+          merge-multiple: true
+          path: dist
+      - uses: pypa/gh-action-pypi-publish@release/v1
+

r4py-4.6.2.1/.gitignore

@@ -0,0 +1,14 @@
+.venv/
+.build/
+dist/
+wheelhouse/
+src/r4py/r-runtime/
+__pycache__/
+*.py[cod]
+*.egg-info/
+.pytest_cache/
+.ruff_cache/
+.Rhistory
+.RData
+Rplots.pdf
+

r4py-4.6.2.1/LICENSE

@@ -0,0 +1,26 @@
+MIT License
+
+Copyright (c) 2026 r4py contributors
+
+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.
+
+This license covers r4py's Python code and build tooling, not bundled R or its
+dependencies. R is licensed under GPL-2.0-or-later; its distribution includes
+COPYING and individual package licenses.
+

r4py-4.6.2.1/PKG-INFO

@@ -0,0 +1,175 @@
+Metadata-Version: 2.5
+Name: r4py
+Version: 4.6.2.1
+Summary: R, ready to roll. A complete R runtime in a Python wheel.
+License-Expression: MIT AND GPL-2.0-or-later
+License-File: LICENSE
+Keywords: R,bundled,cross-platform,r-runtime,runtime,statistics
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+<div align="center">
+
+<h1><img src="logo.svg" alt="Python snakes combined with the R logo" width="200" /></h1>
+
+**R, ready to roll.**
+
+A complete R runtime in a Python wheel.
+
+[![PyPI](https://img.shields.io/pypi/v/r4py?style=flat-square&logo=pypi&logoColor=white)](https://pypi.org/project/r4py/)
+[![Python 3.10+](https://img.shields.io/badge/Python-3.10%2B-3776AB?style=flat-square&logo=python&logoColor=white)](https://www.python.org/)
+[![R 4.6.2](https://img.shields.io/badge/R-4.6.2-276DC3?style=flat-square&logo=r&logoColor=white)](https://www.r-project.org/)
+[![Wheels](https://github.com/JGalego/r4py/actions/workflows/wheels.yml/badge.svg)](https://github.com/JGalego/r4py/actions/workflows/wheels.yml)
+[![Platforms](https://img.shields.io/badge/platforms-Linux%20%7C%20macOS%20%7C%20Windows-475569?style=flat-square)](#install)
+[![Licenses: MIT and GPL-2.0-or-later](https://img.shields.io/badge/license-MIT%20%26%20GPL--2.0%2B-475569?style=flat-square)](#licensing)
+
+</div>
+
+No system R installation. No runtime dependencies on Python packages. No downloads on import. No changes to your process environment.
+
+## Install
+
+```sh
+pip install r4py
+```
+
+Wheels contain R **4.6.2**, base and recommended packages, `libR`, headers, help files, and `R CMD` tools. The Windows wheel omits the CRAN uninstaller and combined reference-manual PDF; individual package help and manuals remain included. Version `4.6.2.1` means R `4.6.2`, packaging revision `1`.
+
+The release workflow targets:
+
+| Platform | Architectures |
+| --- | --- |
+| Linux, glibc 2.28+ | x86-64, ARM64 |
+| macOS 15+ | Intel, Apple Silicon |
+| Windows 10+ | x86-64 |
+
+Linux wheels are repaired with auditwheel; macOS wheels with delocate. Alpine/musl and Windows ARM64 are not supported. Python 3.10+ is required.
+
+## Python
+
+```python
+from subprocess import run
+from r4py import R, R_HOME, R_VERSION, RSCRIPT
+
+print(R_HOME)  # pathlib.Path to the bundled R installation
+print(R_VERSION)  # (4, 6, 2)
+
+run([RSCRIPT, "--vanilla", "-e", "cat(mean(1:10))"], check=True)
+run([RSCRIPT, "analysis.R", "input.csv"], check=True)
+run([R, "CMD", "config", "CC"], check=True)
+```
+
+The executables locate their own runtime, even if the environment is moved. To override a system R environment or configure a child process:
+
+```python
+from r4py import get_env
+
+run(
+    [RSCRIPT, "--vanilla", "-e", "cat(R.home())"],
+    env=get_env({"R_LIBS_USER": "/path/to/my/R/library"}),
+    check=True,
+    capture_output=True,
+    text=True,
+)
+```
+
+`get_env()` copies `os.environ`, applies your overrides, then sets the bundled R home, include, share, and documentation paths. It removes inherited R sub-architecture and R loader overrides. It never changes `os.environ`.
+
+This is a runtime distribution, not a Python-to-R object bridge. Use subprocesses, files, or an independently installed bridge such as rpy2.
+
+## Command line
+
+```sh
+r4py --vanilla -e 'cat(mean(1:10))'
+r4py analysis.R input.csv
+python -m r4py --vanilla -e 'cat(R.version.string)'
+r4py-r                         # interactive R
+r4py-r CMD config CC
+```
+
+`r4py` runs Rscript. `r4py-r` runs R. Arguments, standard streams, and exit codes are passed through. The launchers do not silently select a system R. R startup files behave normally; use `--vanilla` for isolated execution.
+
+## R packages
+
+Recommended packages, including Matrix, MASS, survival, and lattice, are already included. Install additional packages into a **writable library outside the wheel**:
+
+```sh
+r4py --vanilla -e 'lib <- path.expand("~/r4py-library"); dir.create(lib, recursive=TRUE, showWarnings=FALSE); install.packages("jsonlite", lib=lib, repos="https://cloud.r-project.org")'
+```
+
+Set `R_LIBS_USER` to that directory for subsequent runs. Package installation uses the network. Unix wheels include a CA certificate bundle so HTTPS downloads do not depend on the build machine's certificate paths; set `CURL_CA_BUNDLE` to use your own PEM certificate bundle. Compiling source packages requires native build tools and any package-specific system libraries; Windows uses Rtools. `R CMD config` also requires make on Unix. These tools are not bundled. Neither RStudio nor a desktop GUI is included. Headless PDF and PNG graphics are supported.
+
+## Build and test
+
+```sh
+uv sync --no-install-project
+uv run --no-sync ruff check .
+uv run --no-sync pyright
+uv run --no-sync pytest -m 'not runtime'
+uv run --no-sync python build_r_runtime.py
+uv build --wheel
+```
+
+Unix builds need a C/C++/Fortran toolchain, make, tar, a CA certificate bundle, and development files for curl, bzip2, xz, zlib, PCRE2, ICU, readline, Cairo, PNG, JPEG, and TIFF. For example, use the manylinux container recipe in [the wheel workflow](.github/workflows/wheels.yml). `--jobs N` controls compilation parallelism. `--source-archive PATH` uses a local tarball with the same pinned SHA-256 verification.
+
+On Windows, or to reuse a native R installation:
+
+```sh
+uv run --no-sync python build_r_runtime.py --runtime /path/to/R/home
+```
+
+The builder checks the R version, copies the installation, and makes the Unix launchers relocatable. It refuses to overwrite an existing runtime. Wheel builds fail if the runtime is missing or the R version does not match. Source distributions contain build tooling, **not** R.
+
+Local builds inherit the host's OS and library requirements. On Unix, repair the wheel before distributing it; the release workflow does this automatically. For a local Linux build:
+
+```sh
+AUDITWHEEL_LD_LIBRARY_PATH="$PWD/src/r4py/r-runtime/lib" \
+  uvx --from auditwheel --with patchelf auditwheel repair --strip \
+  -w wheelhouse dist/r4py-*.whl
+```
+
+```sh
+uv run --no-sync pytest
+R4PY_REQUIRE_RUNTIME=1 uv run --no-sync pytest -m runtime
+uv run --no-sync python tests/smoke_wheel.py wheelhouse/r4py-*.whl
+```
+
+Without a built runtime, integration tests skip. Release CI requires them, installs each repaired wheel in a path with spaces, hides the original runtime, and tests R execution, recommended native packages, graphics, `R CMD` on Unix, user-library package installation, and exit codes.
+
+## Licensing
+
+r4py's Python code is MIT licensed. Bundled R is **GPL-2.0-or-later**; its packages and linked libraries retain their own licenses. Do not treat the wheel as MIT-only. The Unix wheel recipes retain dependency license notices and the exact RPM or Homebrew source-package inventory.
+
+R source: [R-4.6.2.tar.gz](https://cran.r-project.org/src/base/R-4/R-4.6.2.tar.gz) (SHA-256 `c297040f6392b1dac6e5c0eb398422cfdaedf540ae2205edb9ad0d10cb10ee00`). The build script contains the launcher modifications and is also included in the bundled runtime. Preserve R's `COPYING` and package notices when redistributing. Binary redistribution must comply with R and dependency source-distribution requirements; linking or embedding R may impose further GPL obligations.
+
+The [logo](logo.svg) combines the [Python two-snakes device](https://www.python.org/community/logos/), a trademark of the Python Software Foundation, with the [R logo](https://www.r-project.org/logo/), copyright 2016 The R Foundation. The R artwork and composite arrangement are [CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/); the R artwork is scaled and layered with the Python device. The Python device retains its original shape and colors and remains subject to the [PSF trademark usage policy](https://www.python.org/psf/trademarks/). Neither foundation's endorsement is implied.
+
+## Releases and PyPI
+
+Release each supported stable R version separately: r4py `4.6.2.1` and tag `v4.6.2.1` bundle R `4.6.2`, with packaging revision `1`. Packaging-only fixes increment the fourth component. Keep previous releases available so users can pin their R runtime.
+
+For the first PyPI upload, add a pending publisher at [PyPI account publishing](https://pypi.org/manage/account/publishing/):
+
+| Field | Value |
+| --- | --- |
+| PyPI project name | `r4py` |
+| Repository owner | `JGalego` |
+| Repository name | `r4py` |
+| Workflow filename | `wheels.yml` |
+| Environment name | `pypi` |
+
+The workflow's display name is **Wheels**, but PyPI needs its filename, `wheels.yml`, without the `.github/workflows/` prefix. No PyPI API token is needed.
+
+A release tag builds and tests the source distribution and five wheels without publishing. Once trusted publishing is configured and the release's corresponding source materials are available, run **Wheels** manually on that tag with **publish** enabled:
+
+```sh
+gh workflow run wheels.yml --ref v4.6.2.1 -f publish=true
+```
+
+Publishing uses the `pypi` GitHub environment. Add required reviewers if the repository's billing plan supports them; otherwise the explicit manual publish input is the release gate. Before publishing, verify third-party notices and make the exact corresponding sources for R and bundled dependencies available alongside the binaries.
+

r4py-4.6.2.1/README.md

@@ -0,0 +1,160 @@
+<div align="center">
+
+<h1><img src="logo.svg" alt="Python snakes combined with the R logo" width="200" /></h1>
+
+**R, ready to roll.**
+
+A complete R runtime in a Python wheel.
+
+[![PyPI](https://img.shields.io/pypi/v/r4py?style=flat-square&logo=pypi&logoColor=white)](https://pypi.org/project/r4py/)
+[![Python 3.10+](https://img.shields.io/badge/Python-3.10%2B-3776AB?style=flat-square&logo=python&logoColor=white)](https://www.python.org/)
+[![R 4.6.2](https://img.shields.io/badge/R-4.6.2-276DC3?style=flat-square&logo=r&logoColor=white)](https://www.r-project.org/)
+[![Wheels](https://github.com/JGalego/r4py/actions/workflows/wheels.yml/badge.svg)](https://github.com/JGalego/r4py/actions/workflows/wheels.yml)
+[![Platforms](https://img.shields.io/badge/platforms-Linux%20%7C%20macOS%20%7C%20Windows-475569?style=flat-square)](#install)
+[![Licenses: MIT and GPL-2.0-or-later](https://img.shields.io/badge/license-MIT%20%26%20GPL--2.0%2B-475569?style=flat-square)](#licensing)
+
+</div>
+
+No system R installation. No runtime dependencies on Python packages. No downloads on import. No changes to your process environment.
+
+## Install
+
+```sh
+pip install r4py
+```
+
+Wheels contain R **4.6.2**, base and recommended packages, `libR`, headers, help files, and `R CMD` tools. The Windows wheel omits the CRAN uninstaller and combined reference-manual PDF; individual package help and manuals remain included. Version `4.6.2.1` means R `4.6.2`, packaging revision `1`.
+
+The release workflow targets:
+
+| Platform | Architectures |
+| --- | --- |
+| Linux, glibc 2.28+ | x86-64, ARM64 |
+| macOS 15+ | Intel, Apple Silicon |
+| Windows 10+ | x86-64 |
+
+Linux wheels are repaired with auditwheel; macOS wheels with delocate. Alpine/musl and Windows ARM64 are not supported. Python 3.10+ is required.
+
+## Python
+
+```python
+from subprocess import run
+from r4py import R, R_HOME, R_VERSION, RSCRIPT
+
+print(R_HOME)  # pathlib.Path to the bundled R installation
+print(R_VERSION)  # (4, 6, 2)
+
+run([RSCRIPT, "--vanilla", "-e", "cat(mean(1:10))"], check=True)
+run([RSCRIPT, "analysis.R", "input.csv"], check=True)
+run([R, "CMD", "config", "CC"], check=True)
+```
+
+The executables locate their own runtime, even if the environment is moved. To override a system R environment or configure a child process:
+
+```python
+from r4py import get_env
+
+run(
+    [RSCRIPT, "--vanilla", "-e", "cat(R.home())"],
+    env=get_env({"R_LIBS_USER": "/path/to/my/R/library"}),
+    check=True,
+    capture_output=True,
+    text=True,
+)
+```
+
+`get_env()` copies `os.environ`, applies your overrides, then sets the bundled R home, include, share, and documentation paths. It removes inherited R sub-architecture and R loader overrides. It never changes `os.environ`.
+
+This is a runtime distribution, not a Python-to-R object bridge. Use subprocesses, files, or an independently installed bridge such as rpy2.
+
+## Command line
+
+```sh
+r4py --vanilla -e 'cat(mean(1:10))'
+r4py analysis.R input.csv
+python -m r4py --vanilla -e 'cat(R.version.string)'
+r4py-r                         # interactive R
+r4py-r CMD config CC
+```
+
+`r4py` runs Rscript. `r4py-r` runs R. Arguments, standard streams, and exit codes are passed through. The launchers do not silently select a system R. R startup files behave normally; use `--vanilla` for isolated execution.
+
+## R packages
+
+Recommended packages, including Matrix, MASS, survival, and lattice, are already included. Install additional packages into a **writable library outside the wheel**:
+
+```sh
+r4py --vanilla -e 'lib <- path.expand("~/r4py-library"); dir.create(lib, recursive=TRUE, showWarnings=FALSE); install.packages("jsonlite", lib=lib, repos="https://cloud.r-project.org")'
+```
+
+Set `R_LIBS_USER` to that directory for subsequent runs. Package installation uses the network. Unix wheels include a CA certificate bundle so HTTPS downloads do not depend on the build machine's certificate paths; set `CURL_CA_BUNDLE` to use your own PEM certificate bundle. Compiling source packages requires native build tools and any package-specific system libraries; Windows uses Rtools. `R CMD config` also requires make on Unix. These tools are not bundled. Neither RStudio nor a desktop GUI is included. Headless PDF and PNG graphics are supported.
+
+## Build and test
+
+```sh
+uv sync --no-install-project
+uv run --no-sync ruff check .
+uv run --no-sync pyright
+uv run --no-sync pytest -m 'not runtime'
+uv run --no-sync python build_r_runtime.py
+uv build --wheel
+```
+
+Unix builds need a C/C++/Fortran toolchain, make, tar, a CA certificate bundle, and development files for curl, bzip2, xz, zlib, PCRE2, ICU, readline, Cairo, PNG, JPEG, and TIFF. For example, use the manylinux container recipe in [the wheel workflow](.github/workflows/wheels.yml). `--jobs N` controls compilation parallelism. `--source-archive PATH` uses a local tarball with the same pinned SHA-256 verification.
+
+On Windows, or to reuse a native R installation:
+
+```sh
+uv run --no-sync python build_r_runtime.py --runtime /path/to/R/home
+```
+
+The builder checks the R version, copies the installation, and makes the Unix launchers relocatable. It refuses to overwrite an existing runtime. Wheel builds fail if the runtime is missing or the R version does not match. Source distributions contain build tooling, **not** R.
+
+Local builds inherit the host's OS and library requirements. On Unix, repair the wheel before distributing it; the release workflow does this automatically. For a local Linux build:
+
+```sh
+AUDITWHEEL_LD_LIBRARY_PATH="$PWD/src/r4py/r-runtime/lib" \
+  uvx --from auditwheel --with patchelf auditwheel repair --strip \
+  -w wheelhouse dist/r4py-*.whl
+```
+
+```sh
+uv run --no-sync pytest
+R4PY_REQUIRE_RUNTIME=1 uv run --no-sync pytest -m runtime
+uv run --no-sync python tests/smoke_wheel.py wheelhouse/r4py-*.whl
+```
+
+Without a built runtime, integration tests skip. Release CI requires them, installs each repaired wheel in a path with spaces, hides the original runtime, and tests R execution, recommended native packages, graphics, `R CMD` on Unix, user-library package installation, and exit codes.
+
+## Licensing
+
+r4py's Python code is MIT licensed. Bundled R is **GPL-2.0-or-later**; its packages and linked libraries retain their own licenses. Do not treat the wheel as MIT-only. The Unix wheel recipes retain dependency license notices and the exact RPM or Homebrew source-package inventory.
+
+R source: [R-4.6.2.tar.gz](https://cran.r-project.org/src/base/R-4/R-4.6.2.tar.gz) (SHA-256 `c297040f6392b1dac6e5c0eb398422cfdaedf540ae2205edb9ad0d10cb10ee00`). The build script contains the launcher modifications and is also included in the bundled runtime. Preserve R's `COPYING` and package notices when redistributing. Binary redistribution must comply with R and dependency source-distribution requirements; linking or embedding R may impose further GPL obligations.
+
+The [logo](logo.svg) combines the [Python two-snakes device](https://www.python.org/community/logos/), a trademark of the Python Software Foundation, with the [R logo](https://www.r-project.org/logo/), copyright 2016 The R Foundation. The R artwork and composite arrangement are [CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/); the R artwork is scaled and layered with the Python device. The Python device retains its original shape and colors and remains subject to the [PSF trademark usage policy](https://www.python.org/psf/trademarks/). Neither foundation's endorsement is implied.
+
+## Releases and PyPI
+
+Release each supported stable R version separately: r4py `4.6.2.1` and tag `v4.6.2.1` bundle R `4.6.2`, with packaging revision `1`. Packaging-only fixes increment the fourth component. Keep previous releases available so users can pin their R runtime.
+
+For the first PyPI upload, add a pending publisher at [PyPI account publishing](https://pypi.org/manage/account/publishing/):
+
+| Field | Value |
+| --- | --- |
+| PyPI project name | `r4py` |
+| Repository owner | `JGalego` |
+| Repository name | `r4py` |
+| Workflow filename | `wheels.yml` |
+| Environment name | `pypi` |
+
+The workflow's display name is **Wheels**, but PyPI needs its filename, `wheels.yml`, without the `.github/workflows/` prefix. No PyPI API token is needed.
+
+A release tag builds and tests the source distribution and five wheels without publishing. Once trusted publishing is configured and the release's corresponding source materials are available, run **Wheels** manually on that tag with **publish** enabled:
+
+```sh
+gh workflow run wheels.yml --ref v4.6.2.1 -f publish=true
+```
+
+Publishing uses the `pypi` GitHub environment. Add required reviewers if the repository's billing plan supports them; otherwise the explicit manual publish input is the release gate. Before publishing, verify third-party notices and make the exact corresponding sources for R and bundled dependencies available alongside the binaries.
+