rpy-bridge 0.3.8__tar.gz → 0.4.0__tar.gz

{rpy_bridge-0.3.8/src/rpy_bridge.egg-info → rpy_bridge-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rpy-bridge
-Version: 0.3.8
+Version: 0.4.0
 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
@@ -114,14 +114,16 @@ It enables Python developers to call R functions, scripts, and packages safely w
 
 **From PyPI:**
 
+Install rpy-bridge with rpy2 for full R support
+
 ```bash
-python3 -m pip install rpy-bridge
+python3 -m pip install rpy-bridge rpy2
 ```
 
 or using `uv`:
 
 ```bash
-uv add rpy-bridge
+uv add rpy-bridge rpy2
 ```
 
 **During development (editable install):**

{rpy_bridge-0.3.8 → rpy_bridge-0.4.0}/README.md

@@ -55,14 +55,16 @@ It enables Python developers to call R functions, scripts, and packages safely w
 
 **From PyPI:**
 
+Install rpy-bridge with rpy2 for full R support
+
 ```bash
-python3 -m pip install rpy-bridge
+python3 -m pip install rpy-bridge rpy2
 ```
 
 or using `uv`:
 
 ```bash
-uv add rpy-bridge
+uv add rpy-bridge rpy2
 ```
 
 **During development (editable install):**

{rpy_bridge-0.3.8 → rpy_bridge-0.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "rpy-bridge"
-version = "0.3.8"
+version = "0.4.0"
 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" }

{rpy_bridge-0.3.8 → rpy_bridge-0.4.0}/src/rpy_bridge/rpy2_utils.py

@@ -146,18 +146,14 @@ def find_r_home() -> str | None:
 
 
 # Determine if we're running in CI / testing
-CI_TESTING = (
-    os.environ.get("GITHUB_ACTIONS") == "true" or os.environ.get("TESTING") == "1"
-)
+CI_TESTING = os.environ.get("GITHUB_ACTIONS") == "true" or os.environ.get("TESTING") == "1"
 
 R_HOME = os.environ.get("R_HOME")
 if not R_HOME:
     R_HOME = find_r_home()
     if not R_HOME:
         if CI_TESTING:
-            logger.warning(
-                "R not found; skipping all R-dependent setup in CI/testing environment."
-            )
+            logger.warning("R not found; skipping all R-dependent setup in CI/testing environment.")
             R_HOME = None  # Explicitly None to signal "no R available"
         else:
             raise RuntimeError("R not found. Please install R or add it to PATH.")
@@ -174,7 +170,7 @@ if R_HOME:
         lib_path = os.path.join(R_HOME, "lib")
         if lib_path not in os.environ.get("DYLD_FALLBACK_LIBRARY_PATH", ""):
             os.environ["DYLD_FALLBACK_LIBRARY_PATH"] = (
-                f"{lib_path}:{os.environ.get('DYLD_FALLBACK_LIBRARY_PATH','')}"
+                f"{lib_path}:{os.environ.get('DYLD_FALLBACK_LIBRARY_PATH', '')}"
             )
 
     elif sys.platform.startswith("linux"):
@@ -234,7 +230,7 @@ def _require_rpy2(raise_on_missing: bool = True) -> dict | None:
     except ImportError as e:
         if raise_on_missing:
             raise RuntimeError(
-                "R support requires optional dependency `rpy2`. Install with: pip install rpy-bridge[r]"
+                "R support requires rpy2; install it in your Python env (e.g., pip install rpy2)"
             ) from e
         return None
 
@@ -247,6 +243,46 @@ def _ensure_rpy2() -> dict:
     return _RPY2
 
 
+# ---------------------------------------------------------------------
+# Project root discovery (for this.path / working dir)
+# ---------------------------------------------------------------------
+def _candidate_project_dirs(base: Path, depth: int = 3) -> list[Path]:
+    return [base] + list(base.parents)[:depth]
+
+
+def _has_root_marker(path: Path) -> bool:
+    if (path / ".git").exists():
+        return True
+    if any(path.glob("*.Rproj")):
+        return True
+    if (path / ".here").exists():
+        return True
+    if (path / "DESCRIPTION").exists():
+        return True
+    if (path / "renv.lock").exists():
+        return True
+    return False
+
+
+def _find_project_root(path_to_renv: Path | None, scripts: list[Path]) -> Path | None:
+    # Prefer roots discovered from script locations first; fall back to path_to_renv hints.
+    bases: list[Path] = []
+    if scripts:
+        bases.extend(_candidate_project_dirs(scripts[0].parent))
+    if path_to_renv is not None:
+        bases.extend(_candidate_project_dirs(path_to_renv))
+
+    seen = set()
+    for cand in bases:
+        c = cand.resolve()
+        if c in seen:
+            continue
+        seen.add(c)
+        if _has_root_marker(c):
+            return c
+    return None
+
+
 # ---------------------------------------------------------------------
 # Activate renv
 # ---------------------------------------------------------------------
@@ -254,19 +290,50 @@ def activate_renv(path_to_renv: Path) -> None:
     r = _ensure_rpy2()
     robjects = r["robjects"]
 
+    # Normalize and allow flexible layouts. Users may pass:
+    # - the project root (with renv.lock and renv/)
+    # - the renv directory itself
+    # - a script dir that sits beside or inside the project; we search upwards.
     path_to_renv = path_to_renv.resolve()
-    if path_to_renv.name == "renv" and (path_to_renv / "activate.R").exists():
-        renv_dir = path_to_renv
-        project_dir = path_to_renv.parent
-    else:
-        renv_dir = path_to_renv / "renv"
-        project_dir = path_to_renv
 
-    renv_activate = renv_dir / "activate.R"
-    renv_lock = project_dir / "renv.lock"
-
-    if not renv_activate.exists() or not renv_lock.exists():
-        raise FileNotFoundError(f"[Error] renv environment incomplete: {path_to_renv}")
+    def _candidates(base: Path) -> list[Path]:
+        # Search base, then parents up to 3 levels for renv assets
+        parents = [base] + list(base.parents)[:3]
+        return parents
+
+    project_dir = None
+    renv_dir = None
+    renv_activate = None
+    renv_lock = None
+
+    for cand in _candidates(path_to_renv):
+        # If the candidate *is* a renv dir with activate.R, treat its parent as project
+        cand_is_renv = cand.name == "renv" and (cand / "activate.R").exists()
+        if cand_is_renv:
+            rd = cand
+            pd = cand.parent
+        else:
+            rd = cand / "renv"
+            pd = cand
+
+        activate_path = rd / "activate.R"
+        lock_path = pd / "renv.lock"
+        if not lock_path.exists():
+            alt_lock = rd / "renv.lock"
+            if alt_lock.exists():
+                lock_path = alt_lock
+
+        if activate_path.exists() and lock_path.exists():
+            project_dir = pd
+            renv_dir = rd
+            renv_activate = activate_path
+            renv_lock = lock_path
+            break
+
+    if renv_dir is None or renv_activate is None or renv_lock is None:
+        raise FileNotFoundError(
+            f"[Error] renv environment incomplete: activate.R or renv.lock not found near {path_to_renv}"
+        )
 
     renviron_file = project_dir / ".Renviron"
     if renviron_file.is_file():
@@ -275,9 +342,22 @@ def activate_renv(path_to_renv: Path) -> None:
 
     rprofile_file = project_dir / ".Rprofile"
     if rprofile_file.is_file():
-        robjects.r(f'source("{rprofile_file.as_posix()}")')
-        logger.info(f"[rpy-bridge] .Rprofile sourced: {rprofile_file}")
+        # Source .Rprofile from the project root so any relative paths (e.g. renv/activate.R)
+        # are resolved correctly even when the current R working directory is elsewhere.
+        try:
+            robjects.r(
+                f'old_wd <- getwd(); setwd("{project_dir.as_posix()}"); '
+                f"on.exit(setwd(old_wd), add = TRUE); "
+                f'source("{rprofile_file.as_posix()}")'
+            )
+            logger.info(f"[rpy-bridge] .Rprofile sourced: {rprofile_file}")
+        except Exception as e:  # pragma: no cover - defensive fallback
+            logger.warning(
+                "[rpy-bridge] Failed to source .Rprofile; falling back to renv::activate(): %s",
+                e,
+            )
 
+    # If .Rprofile was absent or failed, ensure renv is loaded directly.
     try:
         robjects.r("suppressMessages(library(renv))")
     except Exception:
@@ -287,6 +367,7 @@ def activate_renv(path_to_renv: Path) -> None:
         )
         robjects.r("library(renv)")
 
+    # Activate renv explicitly in case .Rprofile did not already do it (or failed).
     robjects.r(f'renv::load("{project_dir.as_posix()}")')
     logger.info(f"[rpy-bridge] renv environment loaded for project: {project_dir}")
 
@@ -356,9 +437,10 @@ class RFunctionCaller:
         path_to_renv: str | Path | None = None,
         scripts: str | Path | list[str | Path] | None = None,
         packages: str | list[str] | None = None,
+        headless: bool = True,
+        skip_renv_if_no_r: bool = True,
         **kwargs,  # catch unexpected keywords
     ):
-
         # Handle path_to_renv safely
         if path_to_renv is not None:
             if not isinstance(path_to_renv, Path):
@@ -380,9 +462,7 @@ class RFunctionCaller:
                 scripts = script_path_value
             else:
                 # Both provided → prioritize scripts and ignore script_path
-                logger.warning(
-                    "'script_path' ignored because 'scripts' argument is also provided."
-                )
+                logger.warning("'script_path' ignored because 'scripts' argument is also provided.")
 
         self.scripts = _normalize_scripts(scripts)
 
@@ -399,6 +479,7 @@ class RFunctionCaller:
 
         self.path_to_renv = path_to_renv.resolve() if path_to_renv else None
         self._namespaces: dict[str, Any] = {}
+        self._namespace_roots: dict[str, Path] = {}
 
         # Normalize scripts to a list
         if scripts is None:
@@ -416,6 +497,10 @@ class RFunctionCaller:
         else:
             self.packages = packages
 
+        # Headless mode guards (avoid GUI probing in non-interactive runs)
+        self.headless = headless
+        self.skip_renv_if_no_r = skip_renv_if_no_r
+
         # Lazy-loaded attributes
         self._r = None
         self.ro = None
@@ -434,6 +519,42 @@ class RFunctionCaller:
         self._packages_loaded = False
         self._scripts_loaded = [False] * len(self.scripts)
 
+    def _should_activate_renv(self) -> bool:
+        """Determine if renv activation should run, honoring CI/override knobs."""
+        if not self.path_to_renv:
+            return False
+
+        # Explicit opt-out (e.g., CI jobs that only run pure-Python tests)
+        if os.environ.get("RPY_BRIDGE_SKIP_RENV") in {"1", "true", "TRUE"}:
+            logger.info("[rpy-bridge] Skipping renv activation: RPY_BRIDGE_SKIP_RENV set")
+            return False
+
+        # CI without R available: skip if allowed
+        if CI_TESTING and R_HOME is None and self.skip_renv_if_no_r:
+            logger.info("[rpy-bridge] Skipping renv activation in CI: R_HOME not detected")
+            return False
+
+        # Require R_HOME in non-CI runs
+        if R_HOME is None:
+            raise RuntimeError(
+                "R_HOME not detected; cannot activate renv. Install R or set R_HOME."
+            )
+
+        return True
+
+    def _ensure_headless_env(self) -> None:
+        """Set defaults that prevent R GUI probing (e.g., this.path:::.gui_path)."""
+        if not self.headless:
+            return
+        defaults = {
+            "R_DEFAULT_DEVICE": "png",
+            "R_INTERACTIVE": "false",
+            "R_GUI_APP_VERSION": "0",
+            "RSTUDIO": "0",
+        }
+        for key, val in defaults.items():
+            os.environ.setdefault(key, val)
+
     # -----------------------------------------------------------------
     # Internal: lazy R loading
     # -----------------------------------------------------------------
@@ -442,6 +563,9 @@ class RFunctionCaller:
         Ensure R runtime is initialized and all configured R scripts
         are sourced exactly once, in isolated environments.
         """
+        # Ensure headless-safe env before rpy2 initializes R
+        self._ensure_headless_env()
+
         if self.robjects is None:
             rpy2_dict = _ensure_rpy2()
             self._RPY2 = rpy2_dict  # cache in instance
@@ -457,8 +581,36 @@ class RFunctionCaller:
             self.ListVector = rpy2_dict["ListVector"]
             self.NamedList = rpy2_dict["NamedList"]
 
+        # Activate renv once if requested and allowed
+        if not self._renv_activated and self._should_activate_renv():
+            try:
+                activate_renv(self.path_to_renv)
+                self._renv_activated = True
+                logger.info(
+                    f"[rpy-bridge.RFunctionCaller] renv activated for project: {self.path_to_renv}"
+                )
+            except Exception as e:
+                raise RuntimeError(f"Failed to activate renv at {self.path_to_renv}: {e}") from e
+
         r = self.robjects.r
 
+        # Configure this.path to avoid GUI detection errors in embedded/headless R (e.g., rpy2)
+        try:
+            r('options(this.path.gui = "httpd")')
+            r("options(this.path.verbose = FALSE)")
+            # Patch this.path::.gui_path to avoid GUI detection errors in headless/rpy2 contexts.
+            r(
+                """
+                if (requireNamespace("this.path", quietly = TRUE)) {
+                  try({
+                    assignInNamespace(".gui_path", function(...) "httpd", ns = "this.path")
+                  }, silent = TRUE)
+                }
+                """
+            )
+        except Exception:
+            pass
+
         # Ensure required R package
         self.ensure_r_package("withr")
 
@@ -494,21 +646,27 @@ class RFunctionCaller:
                 r("env <- new.env(parent=globalenv())")
                 r(f'script_path <- "{script_path.as_posix()}"')
 
+                # Determine a root for this script: prefer a discovered project root; else script dir.
+                script_root = _find_project_root(self.path_to_renv, [script_path])
+                # Prefer script-local roots; if none, fall back to script directory.
+                if script_root is None:
+                    script_root = script_path.parent.resolve()
+                script_root_arg = f'"{script_root.as_posix()}"'
+
                 r(
-                    """
+                    f"""
                     withr::with_dir(
-                        dirname(script_path),
-                        sys.source(basename(script_path), envir=env)
+                        {script_root_arg},
+                        sys.source(script_path, envir=env, chdir = TRUE)
                     )
                     """
                 )
 
                 env_obj = r("env")
                 self._namespaces[ns_name] = {
-                    name: env_obj[name]
-                    for name in env_obj.keys()
-                    if callable(env_obj[name])
+                    name: env_obj[name] for name in env_obj.keys() if callable(env_obj[name])
                 }
+                self._namespace_roots[ns_name] = script_root
 
                 logger.info(
                     f"[rpy-bridge.RFunctionCaller] Registered {len(self._namespaces[ns_name])} functions in namespace '{ns_name}'"
@@ -588,9 +746,7 @@ class RFunctionCaller:
             logger.warning(f"Failed to list functions for package '{pkg}'")
             return []
 
-    def list_all_functions(
-        self, include_packages: bool = False
-    ) -> dict[str, list[str]]:
+    def list_all_functions(self, include_packages: bool = False) -> dict[str, list[str]]:
         """
         Return all callable R functions grouped by script namespace and package.
         """
@@ -620,9 +776,7 @@ class RFunctionCaller:
 
         return all_funcs
 
-    def print_function_tree(
-        self, include_packages: bool = False, max_display: int = 10
-    ):
+    def print_function_tree(self, include_packages: bool = False, max_display: int = 10):
         """
         Pretty-print available R functions grouped by namespace.
 
@@ -695,17 +849,11 @@ class RFunctionCaller:
 
                 types = set(type(x) for x in obj if not is_na(x))
                 if types <= {int, float}:
-                    return FloatVector(
-                        [robjects.NA_Real if is_na(x) else float(x) for x in obj]
-                    )
+                    return FloatVector([robjects.NA_Real if is_na(x) else float(x) for x in obj])
                 if types <= {bool}:
-                    return BoolVector(
-                        [robjects.NA_Logical if is_na(x) else x for x in obj]
-                    )
+                    return BoolVector([robjects.NA_Logical if is_na(x) else x for x in obj])
                 if types <= {str}:
-                    return StrVector(
-                        [robjects.NA_Character if is_na(x) else x for x in obj]
-                    )
+                    return StrVector([robjects.NA_Character if is_na(x) else x for x in obj])
                 return ListVector({str(i): self._py2r(v) for i, v in enumerate(obj)})
             if isinstance(obj, dict):
                 return ListVector({k: self._py2r(v) for k, v in obj.items()})
@@ -758,9 +906,7 @@ class RFunctionCaller:
             r(f'suppressMessages(library("{pkg}", character.only=TRUE))')
         except Exception:
             logger.info(f"[rpy-bridge.RFunctionCaller] Package '{pkg}' not found.")
-            logger.warning(
-                f"[rpy-bridge.RFunctionCaller] Installing missing R package: {pkg}"
-            )
+            logger.warning(f"[rpy-bridge.RFunctionCaller] Installing missing R package: {pkg}")
             r(f'install.packages("{pkg}", repos="https://cloud.r-project.org")')
             r(f'suppressMessages(library("{pkg}", character.only=TRUE))')
 
@@ -812,6 +958,7 @@ class RFunctionCaller:
                 if fname in ns_env:
                     func = ns_env[fname]
                     source_info = f"script namespace '{ns_name}'"
+                    namespace_root = self._namespace_roots.get(ns_name)
                 else:
                     raise ValueError(
                         f"Function '{fname}' not found in R script namespace '{ns_name}'"
@@ -821,15 +968,14 @@ class RFunctionCaller:
                     func = self.robjects.r(f"{ns_name}::{fname}")
                     source_info = f"R package '{ns_name}'"
                 except Exception as e:
-                    raise RuntimeError(
-                        f"Failed to resolve R function '{func_name}': {e}"
-                    ) from e
+                    raise RuntimeError(f"Failed to resolve R function '{func_name}': {e}") from e
 
         else:
             for ns_name, ns_env in self._namespaces.items():
                 if func_name in ns_env:
                     func = ns_env[func_name]
                     source_info = f"script namespace '{ns_name}'"
+                    namespace_root = self._namespace_roots.get(ns_name)
                     break
 
             if func is None:
@@ -852,7 +998,18 @@ class RFunctionCaller:
         r_kwargs = {k: self._py2r(v) for k, v in kwargs.items()}
 
         try:
-            result = func(*r_args, **r_kwargs)
+            if source_info and source_info.startswith("script namespace") and namespace_root:
+                r = self.robjects.r
+                try:
+                    r(f'old_wd <- getwd(); setwd("{namespace_root.as_posix()}")')
+                    result = func(*r_args, **r_kwargs)
+                finally:
+                    try:
+                        r("setwd(old_wd)")
+                    except Exception:
+                        pass
+            else:
+                result = func(*r_args, **r_kwargs)
         except Exception as e:
             raise RuntimeError(
                 f"Error calling R function '{func_name}' from {source_info}: {e}"
@@ -927,9 +1084,7 @@ def fix_r_dataframe_types(df: pd.DataFrame) -> pd.DataFrame:
             values = series.dropna()
             if not values.empty and values.between(10000, 40000).all():
                 try:
-                    df[col] = pd.to_datetime("1970-01-01") + pd.to_timedelta(
-                        series, unit="D"
-                    )
+                    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):
@@ -975,20 +1130,14 @@ def clean_r_missing(obj, caller: RFunctionCaller):
 # ---------------------------------------------------------------------
 # DataFrame comparison utilities
 # ---------------------------------------------------------------------
-def normalize_dtypes(
-    df1: pd.DataFrame, df2: pd.DataFrame
-) -> tuple[pd.DataFrame, pd.DataFrame]:
+def normalize_dtypes(df1: pd.DataFrame, df2: pd.DataFrame) -> tuple[pd.DataFrame, pd.DataFrame]:
     for col in df1.columns.intersection(df2.columns):
         df1[col] = df1[col].replace("", pd.NA)
         df2[col] = df2[col].replace("", pd.NA)
         s1, s2 = df1[col], df2[col]
         dtype1, dtype2 = s1.dtype, s2.dtype
-        if (
-            pd.api.types.is_numeric_dtype(dtype1)
-            and pd.api.types.is_object_dtype(dtype2)
-        ) or (
-            pd.api.types.is_object_dtype(dtype1)
-            and pd.api.types.is_numeric_dtype(dtype2)
+        if (pd.api.types.is_numeric_dtype(dtype1) and pd.api.types.is_object_dtype(dtype2)) or (
+            pd.api.types.is_object_dtype(dtype1) and pd.api.types.is_numeric_dtype(dtype2)
         ):
             try:
                 df1[col] = pd.to_numeric(s1, errors="coerce")
@@ -996,9 +1145,7 @@ def normalize_dtypes(
                 continue
             except Exception:
                 pass
-        if pd.api.types.is_numeric_dtype(dtype1) and pd.api.types.is_numeric_dtype(
-            dtype2
-        ):
+        if pd.api.types.is_numeric_dtype(dtype1) and pd.api.types.is_numeric_dtype(dtype2):
             df1[col] = df1[col].astype("float64")
             df2[col] = df2[col].astype("float64")
             continue
@@ -1008,9 +1155,7 @@ def normalize_dtypes(
     return df1, df2
 
 
-def align_numeric_dtypes(
-    df1: pd.DataFrame, df2: pd.DataFrame
-) -> tuple[pd.DataFrame, pd.DataFrame]:
+def align_numeric_dtypes(df1: pd.DataFrame, df2: pd.DataFrame) -> tuple[pd.DataFrame, pd.DataFrame]:
     for col in df1.columns.intersection(df2.columns):
         s1, s2 = df1[col].replace("", pd.NA), df2[col].replace("", pd.NA)
         try:
@@ -1026,9 +1171,7 @@ def align_numeric_dtypes(
     return df1, df2
 
 
-def compare_r_py_dataframes(
-    df1: pd.DataFrame, df2: pd.DataFrame, float_tol: float = 1e-8
-) -> dict:
+def compare_r_py_dataframes(df1: pd.DataFrame, df2: pd.DataFrame, float_tol: float = 1e-8) -> dict:
     results: dict[str, Any] = {
         "shape_mismatch": False,
         "columns_mismatch": False,
@@ -1055,9 +1198,7 @@ def compare_r_py_dataframes(
     df1_aligned, df2_aligned = df1.loc[:, common_cols], df2.loc[:, common_cols]
     for col in common_cols:
         col_py, col_r = df1_aligned[col], df2_aligned[col]
-        if pd.api.types.is_numeric_dtype(col_py) and pd.api.types.is_numeric_dtype(
-            col_r
-        ):
+        if pd.api.types.is_numeric_dtype(col_py) and pd.api.types.is_numeric_dtype(col_r):
             col_py, col_r = col_py.align(col_r)
             close = np.isclose(
                 col_py.fillna(np.nan),

{rpy_bridge-0.3.8 → rpy_bridge-0.4.0/src/rpy_bridge.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rpy-bridge
-Version: 0.3.8
+Version: 0.4.0
 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
@@ -114,14 +114,16 @@ It enables Python developers to call R functions, scripts, and packages safely w
 
 **From PyPI:**
 
+Install rpy-bridge with rpy2 for full R support
+
 ```bash
-python3 -m pip install rpy-bridge
+python3 -m pip install rpy-bridge rpy2
 ```
 
 or using `uv`:
 
 ```bash
-uv add rpy-bridge
+uv add rpy-bridge rpy2
 ```
 
 **During development (editable install):**