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

{rpy_bridge-0.3.9/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.9
+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

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

@@ -1,6 +1,6 @@
 [project]
 name = "rpy-bridge"
-version = "0.3.9"
+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.9 → rpy_bridge-0.4.0}/src/rpy_bridge/rpy2_utils.py

@@ -230,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
 
@@ -243,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
 # ---------------------------------------------------------------------
@@ -250,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():
@@ -271,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:
@@ -283,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}")
 
@@ -352,6 +437,8 @@ 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
@@ -392,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:
@@ -409,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
@@ -427,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
     # -----------------------------------------------------------------
@@ -435,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
@@ -450,8 +581,8 @@ class RFunctionCaller:
             self.ListVector = rpy2_dict["ListVector"]
             self.NamedList = rpy2_dict["NamedList"]
 
-        # Activate renv once if requested
-        if self.path_to_renv and not self._renv_activated:
+        # 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
@@ -463,6 +594,23 @@ class RFunctionCaller:
 
         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")
 
@@ -498,11 +646,18 @@ 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)
                     )
                     """
                 )
@@ -511,6 +666,7 @@ class RFunctionCaller:
                 self._namespaces[ns_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}'"
@@ -802,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}'"
@@ -818,6 +975,7 @@ class RFunctionCaller:
                 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:
@@ -840,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}"

{rpy_bridge-0.3.9 → 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.9
+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