rpy-bridge 0.5.0__tar.gz → 0.5.2__tar.gz

{rpy_bridge-0.5.0/src/rpy_bridge.egg-info → rpy_bridge-0.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rpy-bridge
-Version: 0.5.0
+Version: 0.5.2
 Summary: Python-to-R interoperability engine with environment management, type-safe conversions, data normalization, and safe R function execution.
 Author-email: Victoria Cheung <victoriakcheung@gmail.com>
 License: MIT License
@@ -59,17 +59,11 @@ Dynamic: license-file
 
 # rpy-bridge
 
-**rpy-bridge** is a Python-controlled **R execution orchestrator** that enables
-Python code to run R functions, scripts, and packages with **reproducible
-filesystem and environment semantics**.
-
-It is built on top of `rpy2`, but unlike thin wrappers, rpy-bridge stabilizes how
-R code is executed when invoked from Python: project roots are inferred, `renv`
-environments can be activated out-of-tree, relative paths behave as expected,
-and return values are normalized for safe Python consumption.
-
-This makes rpy-bridge suitable for production pipelines, CI, and bilingual
-Python/R teams where R code must run reliably outside an interactive R session.
+**rpy-bridge** is a Python-controlled **R execution orchestrator** (not a thin
+rpy2 wrapper). It delivers deterministic, headless-safe R startup; project-root
+inference; out-of-tree `renv` activation; isolated script namespaces; and robust
+Python↔R conversions with dtype/NA normalization. Use it when you need
+reproducible R execution from Python in production pipelines and CI.
 
 **Latest release:** [`rpy-bridge` on PyPI](https://pypi.org/project/rpy-bridge/)
 
@@ -77,20 +71,40 @@ Python/R teams where R code must run reliably outside an interactive R session.
 
 ## What this is (and is not)
 
-rpy-bridge **is not a thin rpy2 wrapper**.
+rpy-bridge **is not a thin rpy2 wrapper**. Key differences:
 
-Typical rpy2 usage assumes:
-- the Python working directory is the R project root
-- `renv` lives next to the executing script
-- relative paths resolve correctly by default
-- all R code executes in `globalenv()`
+- Infers R project roots via markers (`.git`, `.Rproj`, `renv.lock`, `DESCRIPTION`, `.here`)
+- Activates `renv` even when it lives outside the calling directory
+- Executes from the inferred project root so relative paths behave as R expects
+- Runs headless by default (no GUI probing), isolates scripts from `globalenv()`
+- Normalizes return values for Python (NAs, dtypes, data.frames) and offers comparison helpers
 
-These assumptions break quickly in real-world Python workflows.
+---
 
-rpy-bridge instead provides a **controlled R runtime** with explicit guarantees
-around execution context, filesystem behavior, and environment activation.
+## Quickstart
 
----
+Call a package function (no scripts):
+
+```python
+from rpy_bridge import RFunctionCaller
+
+rfc = RFunctionCaller()
+samples = rfc.call("stats::rnorm", 5, mean=0, sd=1)
+median_val = rfc.call("stats::median", samples)
+```
+
+Call a function from a local script with `renv` (out-of-tree allowed):
+
+```python
+from pathlib import Path
+from rpy_bridge import RFunctionCaller
+
+project_dir = Path("/path/to/your-r-project")
+script = project_dir / "scripts" / "example.R"
+
+rfc = RFunctionCaller(path_to_renv=project_dir, scripts=script)
+result = rfc.call("some_function", 42, named_arg="value")
+```
 
 ## Core capabilities
 
@@ -161,7 +175,7 @@ reproducibility and avoid side effects during execution.
 ### Prerequisites
 
 - System R installed and available on `PATH`
-- Python 3.12+
+- Python 3.11+ (tested on 3.11–3.12)
 
 ### From PyPI
 
@@ -199,33 +213,7 @@ uv sync
 
 ## Usage
 
-### Call a function from a local R script
-
-```python
-from pathlib import Path
-from rpy_bridge import RFunctionCaller
-
-project_dir = Path("/path/to/your-r-project")
-script = project_dir / "scripts" / "example.R"
-
-caller = RFunctionCaller(
-    path_to_renv=project_dir,
-    script_path=script,
-)
-
-result = caller.call("some_function", 42, named_arg="value")
-```
-
-### Call base R functions (no local script)
-
-```python
-from rpy_bridge import RFunctionCaller
-
-caller = RFunctionCaller(path_to_renv=None)
-
-samples = caller.call("stats::rnorm", 10, mean=0, sd=1)
-median_val = caller.call("stats::median", samples)
-```
+See Quickstart above and examples in `examples/basic_usage.py`.
 
 ---
 

{rpy_bridge-0.5.0 → rpy_bridge-0.5.2}/README.md

@@ -1,16 +1,10 @@
 # rpy-bridge
 
-**rpy-bridge** is a Python-controlled **R execution orchestrator** that enables
-Python code to run R functions, scripts, and packages with **reproducible
-filesystem and environment semantics**.
-
-It is built on top of `rpy2`, but unlike thin wrappers, rpy-bridge stabilizes how
-R code is executed when invoked from Python: project roots are inferred, `renv`
-environments can be activated out-of-tree, relative paths behave as expected,
-and return values are normalized for safe Python consumption.
-
-This makes rpy-bridge suitable for production pipelines, CI, and bilingual
-Python/R teams where R code must run reliably outside an interactive R session.
+**rpy-bridge** is a Python-controlled **R execution orchestrator** (not a thin
+rpy2 wrapper). It delivers deterministic, headless-safe R startup; project-root
+inference; out-of-tree `renv` activation; isolated script namespaces; and robust
+Python↔R conversions with dtype/NA normalization. Use it when you need
+reproducible R execution from Python in production pipelines and CI.
 
 **Latest release:** [`rpy-bridge` on PyPI](https://pypi.org/project/rpy-bridge/)
 
@@ -18,20 +12,40 @@ Python/R teams where R code must run reliably outside an interactive R session.
 
 ## What this is (and is not)
 
-rpy-bridge **is not a thin rpy2 wrapper**.
+rpy-bridge **is not a thin rpy2 wrapper**. Key differences:
 
-Typical rpy2 usage assumes:
-- the Python working directory is the R project root
-- `renv` lives next to the executing script
-- relative paths resolve correctly by default
-- all R code executes in `globalenv()`
+- Infers R project roots via markers (`.git`, `.Rproj`, `renv.lock`, `DESCRIPTION`, `.here`)
+- Activates `renv` even when it lives outside the calling directory
+- Executes from the inferred project root so relative paths behave as R expects
+- Runs headless by default (no GUI probing), isolates scripts from `globalenv()`
+- Normalizes return values for Python (NAs, dtypes, data.frames) and offers comparison helpers
 
-These assumptions break quickly in real-world Python workflows.
+---
 
-rpy-bridge instead provides a **controlled R runtime** with explicit guarantees
-around execution context, filesystem behavior, and environment activation.
+## Quickstart
 
----
+Call a package function (no scripts):
+
+```python
+from rpy_bridge import RFunctionCaller
+
+rfc = RFunctionCaller()
+samples = rfc.call("stats::rnorm", 5, mean=0, sd=1)
+median_val = rfc.call("stats::median", samples)
+```
+
+Call a function from a local script with `renv` (out-of-tree allowed):
+
+```python
+from pathlib import Path
+from rpy_bridge import RFunctionCaller
+
+project_dir = Path("/path/to/your-r-project")
+script = project_dir / "scripts" / "example.R"
+
+rfc = RFunctionCaller(path_to_renv=project_dir, scripts=script)
+result = rfc.call("some_function", 42, named_arg="value")
+```
 
 ## Core capabilities
 
@@ -102,7 +116,7 @@ reproducibility and avoid side effects during execution.
 ### Prerequisites
 
 - System R installed and available on `PATH`
-- Python 3.12+
+- Python 3.11+ (tested on 3.11–3.12)
 
 ### From PyPI
 
@@ -140,33 +154,7 @@ uv sync
 
 ## Usage
 
-### Call a function from a local R script
-
-```python
-from pathlib import Path
-from rpy_bridge import RFunctionCaller
-
-project_dir = Path("/path/to/your-r-project")
-script = project_dir / "scripts" / "example.R"
-
-caller = RFunctionCaller(
-    path_to_renv=project_dir,
-    script_path=script,
-)
-
-result = caller.call("some_function", 42, named_arg="value")
-```
-
-### Call base R functions (no local script)
-
-```python
-from rpy_bridge import RFunctionCaller
-
-caller = RFunctionCaller(path_to_renv=None)
-
-samples = caller.call("stats::rnorm", 10, mean=0, sd=1)
-median_val = caller.call("stats::median", samples)
-```
+See Quickstart above and examples in `examples/basic_usage.py`.
 
 ---
 

{rpy_bridge-0.5.0 → rpy_bridge-0.5.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "rpy-bridge"
-version = "0.5.0"
+version = "0.5.2"
 description = "Python-to-R interoperability engine with environment management, type-safe conversions, data normalization, and safe R function execution."
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -41,11 +41,6 @@ classifiers = [
 
 ]
 
-[project.optional-dependencies]
-r = ["rpy2>=3.5"]
-dev = ["ipykernel>=7.1.0"]
-docs = ["sphinx", "myst-parser"]
-
 [project.urls]
 Homepage = "https://github.com/vic-cheung/rpy-bridge"
 "Issue Tracker" = "https://github.com/vic-cheung/rpy-bridge/issues"
@@ -57,6 +52,11 @@ build-backend = "setuptools.build_meta"
 # -------------------------------
 # uv dev dependencies
 # -------------------------------
+[project.optional-dependencies]
+r = ["rpy2>=3.5"]
+dev = ["ipykernel>=7.1.0"]
+docs = ["sphinx", "myst-parser"]
+
 [tool.uv]
 dev-dependencies = [
     "ruff>=0.6",

{rpy_bridge-0.5.0 → rpy_bridge-0.5.2}/src/rpy_bridge/core.py

@@ -188,6 +188,16 @@ class RFunctionCaller:
         except Exception:
             pass
 
+        # Pass the current Python interpreter path to R so reticulate can use the same Python
+        # This is critical for nested Python→R→Python calls via reticulate
+        import sys
+
+        python_executable = sys.executable
+        venv_path = os.environ.get("VIRTUAL_ENV", "")
+        r(f'Sys.setenv(RPY_BRIDGE_PYTHON_EXECUTABLE = "{python_executable}")')
+        if venv_path:
+            r(f'Sys.setenv(VIRTUAL_ENV = "{venv_path}")')
+
         self.ensure_r_package("withr")
 
         if not hasattr(self, "_namespaces"):
@@ -357,9 +367,33 @@ class RFunctionCaller:
         with localconverter(robjects.default_converter + pandas2ri.converter):
             if is_na(obj):
                 return robjects.NULL
+            if isinstance(obj, pd.Timestamp):
+                # Convert single Timestamp to R Date (days since 1970-01-01)
+                days_since_epoch = (obj - pd.Timestamp("1970-01-01")).days
+                r = self.robjects.r
+                return r(f"as.Date({days_since_epoch}, origin='1970-01-01')")
             if isinstance(obj, pd.DataFrame):
-                return pandas2ri.py2rpy(obj)
+                # Convert datetime columns to numeric (days since epoch) before R conversion
+                df_copy = obj.copy()
+                for col in df_copy.columns:
+                    if pd.api.types.is_datetime64_any_dtype(df_copy[col]):
+                        df_copy[col] = (df_copy[col] - pd.Timestamp("1970-01-01")).dt.days
+                r_df = pandas2ri.py2rpy(df_copy)
+                # Convert numeric date columns back to R Date class
+                r = self.robjects.r
+                for col in obj.columns:
+                    if pd.api.types.is_datetime64_any_dtype(obj[col]):
+                        r(f'class({r_df.rx2(col).r_repr()}) <- "Date"')
+                return r_df
             if isinstance(obj, pd.Series):
+                if pd.api.types.is_datetime64_any_dtype(obj):
+                    # Convert datetime Series to R Date vector
+                    days = (obj - pd.Timestamp("1970-01-01")).dt.days.tolist()
+                    r = self.robjects.r
+                    days_vec = FloatVector(
+                        [robjects.NA_Real if pd.isna(d) else float(d) for d in days]
+                    )
+                    return r("function(x) { class(x) <- 'Date'; x }")(days_vec)
                 return self._py2r(obj.tolist())
             if isinstance(obj, (int, float, bool, str)):
                 return obj

{rpy_bridge-0.5.0 → rpy_bridge-0.5.2}/src/rpy_bridge/dataframe.py

@@ -4,6 +4,8 @@ DataFrame cleaning and post-processing utilities for R ↔ Python workflows.
 
 from __future__ import annotations
 
+import re
+
 import numpy as np
 import pandas as pd
 
@@ -34,6 +36,21 @@ def normalize_single_df_dtypes(df: pd.DataFrame) -> pd.DataFrame:
     return df
 
 
+# Token-based patterns to detect date/time columns; avoids substring matches like "endotoxin" or "runtime".
+_DATE_TOKEN_RE = re.compile(
+    r"(?<![a-z0-9])"
+    r"(?:date|dt|time|dob|visit|start|end|created|updated|modified|timestamp|datetime|ts|dos)"
+    r"(?![a-z0-9])",
+    re.IGNORECASE,
+)
+
+
+def _looks_like_date_column(col_name: str) -> bool:
+    """Check if column name suggests it contains date values."""
+    col_lower = str(col_name).lower()
+    return bool(_DATE_TOKEN_RE.search(col_lower))
+
+
 def fix_r_dataframe_types(df: pd.DataFrame) -> pd.DataFrame:
     for col in df.columns:
         series = df[col]
@@ -41,13 +58,18 @@ def fix_r_dataframe_types(df: pd.DataFrame) -> pd.DataFrame:
             df[col] = series.mask(series == -2147483648, pd.NA)
         if pd.api.types.is_numeric_dtype(series):
             values = series.dropna()
-            if not values.empty and values.between(10000, 40000).all():
+            # Only convert to date if values are in R's date range AND column name suggests a date
+            if (
+                not values.empty
+                and values.between(10000, 40000).all()
+                and _looks_like_date_column(col)
+            ):
                 try:
                     df[col] = pd.to_datetime("1970-01-01") + pd.to_timedelta(series, unit="D")
                 except Exception:
                     pass
         if pd.api.types.is_datetime64tz_dtype(series):
-            df[col] = series.dt.tz_localize(None)
+            df[col] = series.dt.tz_convert(None)
     return df
 
 

{rpy_bridge-0.5.0 → rpy_bridge-0.5.2/src/rpy_bridge.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rpy-bridge
-Version: 0.5.0
+Version: 0.5.2
 Summary: Python-to-R interoperability engine with environment management, type-safe conversions, data normalization, and safe R function execution.
 Author-email: Victoria Cheung <victoriakcheung@gmail.com>
 License: MIT License
@@ -59,17 +59,11 @@ Dynamic: license-file
 
 # rpy-bridge
 
-**rpy-bridge** is a Python-controlled **R execution orchestrator** that enables
-Python code to run R functions, scripts, and packages with **reproducible
-filesystem and environment semantics**.
-
-It is built on top of `rpy2`, but unlike thin wrappers, rpy-bridge stabilizes how
-R code is executed when invoked from Python: project roots are inferred, `renv`
-environments can be activated out-of-tree, relative paths behave as expected,
-and return values are normalized for safe Python consumption.
-
-This makes rpy-bridge suitable for production pipelines, CI, and bilingual
-Python/R teams where R code must run reliably outside an interactive R session.
+**rpy-bridge** is a Python-controlled **R execution orchestrator** (not a thin
+rpy2 wrapper). It delivers deterministic, headless-safe R startup; project-root
+inference; out-of-tree `renv` activation; isolated script namespaces; and robust
+Python↔R conversions with dtype/NA normalization. Use it when you need
+reproducible R execution from Python in production pipelines and CI.
 
 **Latest release:** [`rpy-bridge` on PyPI](https://pypi.org/project/rpy-bridge/)
 
@@ -77,20 +71,40 @@ Python/R teams where R code must run reliably outside an interactive R session.
 
 ## What this is (and is not)
 
-rpy-bridge **is not a thin rpy2 wrapper**.
+rpy-bridge **is not a thin rpy2 wrapper**. Key differences:
 
-Typical rpy2 usage assumes:
-- the Python working directory is the R project root
-- `renv` lives next to the executing script
-- relative paths resolve correctly by default
-- all R code executes in `globalenv()`
+- Infers R project roots via markers (`.git`, `.Rproj`, `renv.lock`, `DESCRIPTION`, `.here`)
+- Activates `renv` even when it lives outside the calling directory
+- Executes from the inferred project root so relative paths behave as R expects
+- Runs headless by default (no GUI probing), isolates scripts from `globalenv()`
+- Normalizes return values for Python (NAs, dtypes, data.frames) and offers comparison helpers
 
-These assumptions break quickly in real-world Python workflows.
+---
 
-rpy-bridge instead provides a **controlled R runtime** with explicit guarantees
-around execution context, filesystem behavior, and environment activation.
+## Quickstart
 
----
+Call a package function (no scripts):
+
+```python
+from rpy_bridge import RFunctionCaller
+
+rfc = RFunctionCaller()
+samples = rfc.call("stats::rnorm", 5, mean=0, sd=1)
+median_val = rfc.call("stats::median", samples)
+```
+
+Call a function from a local script with `renv` (out-of-tree allowed):
+
+```python
+from pathlib import Path
+from rpy_bridge import RFunctionCaller
+
+project_dir = Path("/path/to/your-r-project")
+script = project_dir / "scripts" / "example.R"
+
+rfc = RFunctionCaller(path_to_renv=project_dir, scripts=script)
+result = rfc.call("some_function", 42, named_arg="value")
+```
 
 ## Core capabilities
 
@@ -161,7 +175,7 @@ reproducibility and avoid side effects during execution.
 ### Prerequisites
 
 - System R installed and available on `PATH`
-- Python 3.12+
+- Python 3.11+ (tested on 3.11–3.12)
 
 ### From PyPI
 
@@ -199,33 +213,7 @@ uv sync
 
 ## Usage
 
-### Call a function from a local R script
-
-```python
-from pathlib import Path
-from rpy_bridge import RFunctionCaller
-
-project_dir = Path("/path/to/your-r-project")
-script = project_dir / "scripts" / "example.R"
-
-caller = RFunctionCaller(
-    path_to_renv=project_dir,
-    script_path=script,
-)
-
-result = caller.call("some_function", 42, named_arg="value")
-```
-
-### Call base R functions (no local script)
-
-```python
-from rpy_bridge import RFunctionCaller
-
-caller = RFunctionCaller(path_to_renv=None)
-
-samples = caller.call("stats::rnorm", 10, mean=0, sd=1)
-median_val = caller.call("stats::median", samples)
-```
+See Quickstart above and examples in `examples/basic_usage.py`.
 
 ---