ygg 0.1.56__py3-none-any.whl → 0.1.60__py3-none-any.whl

yggdrasil/pyutils/callable_serde.py

@@ -497,9 +497,8 @@ class CallableSerde:
         kwargs: Optional[Dict[str, Any]] = None,
         *,
         result_tag: str = "__CALLABLE_SERDE_RESULT__",
-        prefer: str = "dill",
         byte_limit: int = 64 * 1024,
-        dump_env: str = "none",           # "none" | "globals" | "closure" | "both"
+        dump_env: str = "none", # "none" | "globals" | "closure" | "both"
         filter_used_globals: bool = True,
         env_keys: Optional[Iterable[str]] = None,
         env_variables: Optional[Dict[str, str]] = None,
@@ -697,26 +696,18 @@ sys.stdout.flush()
                 string_result.replace("DBXPATH:", "")
             )
 
-            if path.name.endswith(".parquet"):
-                import pandas
-
-                with path.open(mode="rb") as f:
-                    buf = io.BytesIO(f.read_all_bytes())
-
+            try:
+                df = path.read_pandas()
+            finally:
                 path.rmfile()
-                buf.seek(0)
-                return pandas.read_parquet(buf)
 
-            with path.open(mode="rb") as f:
-                blob = f.read_all_bytes()
+            return df
 
-            path.rmfile()
-        else:
-            # Strict base64 decode (rejects junk chars)
-            try:
-                blob = base64.b64decode(string_result.encode("ascii"), validate=True)
-            except (UnicodeEncodeError, binascii.Error) as e:
-                raise ValueError("Invalid base64 payload after result tag (corrupted/contaminated).") from e
+        # Strict base64 decode (rejects junk chars)
+        try:
+            blob = base64.b64decode(string_result.encode("ascii"), validate=True)
+        except (UnicodeEncodeError, binascii.Error) as e:
+            raise ValueError("Invalid base64 payload after result tag (corrupted/contaminated).") from e
 
         raw = _decode_result_blob(blob)
         try:
@@ -725,3 +716,5 @@ sys.stdout.flush()
             raise ValueError("Failed to dill.loads decoded payload") from e
 
         return result
+
+

yggdrasil/pyutils/exceptions.py

@@ -86,6 +86,19 @@ def parse_exception_from_traceback(tb_text: str) -> ParsedException:
     return ParsedException(RuntimeError, clean, "RuntimeError")
 
 
+def missing_module_name(exc: BaseException) -> str | None:
+    if isinstance(exc, ModuleNotFoundError):
+        if getattr(exc, "name", None):
+            return exc.name
+
+        # fallback: parse from message/args
+        msg = exc.args[0] if exc.args else str(exc)
+        m = re.search(r"No module named ['\"]([^'\"]+)['\"]", msg)
+        return m.group(1) if m else None
+
+    return None
+
+
 def raise_parsed_traceback(tb_text: str, *, attach_as_cause: bool = True) -> None:
     """
     Infer exception from traceback text and raise it.
@@ -94,6 +107,9 @@ def raise_parsed_traceback(tb_text: str, *, attach_as_cause: bool = True) -> Non
     parsed = parse_exception_from_traceback(tb_text)
     exc = parsed.exc_type(parsed.message) if parsed.message else parsed.exc_type()
 
+    if isinstance(exc, ModuleNotFoundError):
+        exc.name = missing_module_name(exc)
+
     if attach_as_cause:
         raise exc from RemoteTraceback(tb_text)
     raise exc

yggdrasil/pyutils/python_env.py

@@ -441,19 +441,20 @@ class PythonEnv:
         Returns:
             PythonEnv representing the current environment.
         """
-        venv = os.environ.get("VIRTUAL_ENV")
-        if venv:
-            log.debug("current env from VIRTUAL_ENV=%s", venv)
-            return cls(Path(venv))
+        global CURRENT_PYTHON_ENV
 
-        exe = Path(sys.executable).expanduser().resolve()
-        parent = exe.parent
-        if parent.name in ("bin", "Scripts"):
-            log.debug("current env inferred from sys.executable=%s", str(exe))
-            return cls(parent.parent)
+        if CURRENT_PYTHON_ENV is None:
+            exe = Path(sys.executable).expanduser().resolve()
+            parent = exe.parent
 
-        log.debug("current env fallback to sys.prefix=%s", sys.prefix)
-        return cls(Path(sys.prefix))
+            if parent.name in ("bin", "Scripts"):
+                log.debug("current env inferred from sys.executable=%s", str(exe))
+                CURRENT_PYTHON_ENV = cls(parent.parent)
+            else:
+                log.debug("current env fallback to sys.prefix=%s", sys.prefix)
+                CURRENT_PYTHON_ENV = cls(Path(sys.prefix))
+
+        return CURRENT_PYTHON_ENV
 
     @classmethod
     def ensure_uv(
@@ -1510,7 +1511,7 @@ print("RESULT:" + json.dumps(top_level))""".strip()
 
 
 # Snapshot singleton (import-time)
-CURRENT_PYTHON_ENV: PythonEnv = PythonEnv.get_current()
+CURRENT_PYTHON_ENV: PythonEnv = None
 
 
 if __name__ == "__main__":

yggdrasil/pyutils/waiting_config.py

@@ -0,0 +1,171 @@
+import datetime as dt
+import time
+from dataclasses import dataclass
+from typing import Optional, Union
+
+__all__ = ["WaitingConfig", "WaitingConfigArg"]
+
+
+def _safe_seconds_tick(ticks: Union[int, float, dt.timedelta]):
+    if isinstance(ticks, dt.timedelta):
+        return ticks.total_seconds()
+    return ticks
+
+
+DEFAULT_TIMEOUT_TICKS = float(20 * 60) # 20 minutes
+WaitingConfigArg = Union["WaitingConfig", dict, int, float, dt.datetime, bool]
+
+
+@dataclass(frozen=True)
+class WaitingConfig:
+    timeout: float = DEFAULT_TIMEOUT_TICKS
+    interval: float = 2.0
+    backoff: float = 1.0
+    max_interval: float = 10.0
+
+    @property
+    def timeout_timedelta(self) -> dt.timedelta:
+        return dt.timedelta(seconds=self.timeout)
+
+    @classmethod
+    def default(cls):
+        return DEFAULT_WAITING_CONFIG
+
+    @staticmethod
+    def _to_seconds(value) -> Optional[float]:
+        if value is None:
+            return None
+        if isinstance(value, dt.timedelta):
+            return float(value.total_seconds())
+        if isinstance(value, (int, float)):
+            return float(value)
+        raise TypeError(f"Expected seconds as int/float/timedelta, got {type(value)!r}")
+
+    @staticmethod
+    def _deadline_to_timeout(deadline: dt.datetime) -> float:
+        if not isinstance(deadline, dt.datetime):
+            raise TypeError(f"deadline must be datetime, got {type(deadline)!r}")
+        now = dt.datetime.now(tz=deadline.tzinfo) if deadline.tzinfo else dt.datetime.now()
+        return (deadline - now).total_seconds()
+
+    @classmethod
+    def check_arg(
+        cls,
+        arg: Optional[WaitingConfigArg] = None,
+        timeout: Optional[Union[int, float, dt.timedelta]] = None,
+        interval: Optional[Union[int, float, dt.timedelta]] = None,
+        backoff: Optional[Union[int, float, dt.timedelta]] = None,
+        max_interval: Optional[Union[int, float, dt.timedelta]] = None,
+    ) -> Optional["WaitingConfig"]:
+        base_timeout: Optional[float] = None
+        base_interval: Optional[float] = None
+        base_backoff: Optional[float] = None
+        base_max_interval: Optional[float] = None
+
+        if arg is not None:
+            if isinstance(arg, cls):
+                if timeout is None and interval is None and backoff is None and max_interval is None:
+                    return arg
+
+                base_timeout = arg.timeout
+                base_interval = arg.interval
+                base_backoff = arg.backoff
+                base_max_interval = arg.max_interval
+
+            elif isinstance(arg, bool):
+                base_timeout = DEFAULT_TIMEOUT_TICKS if arg else 0.0
+                base_interval = 2.0
+                base_backoff = 2.0
+                base_max_interval = 15.0
+
+            elif isinstance(arg, (int, float, dt.timedelta)):
+                base_timeout = cls._to_seconds(arg)
+
+            elif isinstance(arg, dt.datetime):
+                base_timeout = float(cls._deadline_to_timeout(arg))
+
+            elif isinstance(arg, dict):
+                if "deadline" in arg and "timeout" in arg:
+                    raise ValueError("Provide only one of 'deadline' or 'timeout' in WaitingOptions dict.")
+
+                if "deadline" in arg and arg["deadline"] is not None:
+                    base_timeout = float(cls._deadline_to_timeout(arg["deadline"]))
+                else:
+                    base_timeout = cls._to_seconds(arg.get("timeout"))
+
+                base_interval = cls._to_seconds(arg.get("interval"))
+                base_backoff = cls._to_seconds(arg.get("backoff"))
+                base_max_interval = cls._to_seconds(arg.get("max_interval"))
+
+            else:
+                raise TypeError(f"Unsupported WaitingOptions arg type: {type(arg)!r}")
+
+        # explicit kwargs win
+        final_timeout = cls._to_seconds(timeout) if timeout is not None else base_timeout
+        final_interval = cls._to_seconds(interval) if interval is not None else base_interval
+        final_backoff = cls._to_seconds(backoff) if backoff is not None else base_backoff
+        final_max_interval = cls._to_seconds(max_interval) if max_interval is not None else base_max_interval
+
+        # defaults to match non-Optional signature
+        if final_timeout is None:
+            final_timeout = 0.0
+        elif final_timeout < 0:
+            final_timeout = 0.0
+
+        if final_interval is None:
+            final_interval = 2.0
+
+        if final_backoff is None:
+            final_backoff = 2.0
+        elif final_backoff < 1:
+            final_backoff = 2.0
+
+        if final_max_interval is None:
+            final_max_interval = 10.0
+
+        return cls(
+            timeout=float(final_timeout),
+            interval=float(final_interval),
+            backoff=float(final_backoff),
+            max_interval=float(final_max_interval),
+        )
+
+    def sleep(self, iteration: int, start: float | None = None) -> None:
+        """
+        iteration is 0-based (first wait => iteration=0)
+
+        - interval == 0 => no sleep
+        - backoff >= 1 => interval * backoff**iteration
+        - max_interval == 0 => no cap, else cap sleep to max_interval
+        - if start is provided and timeout > 0:
+            * raise TimeoutError if already out of time
+            * cap sleep so we don't oversleep past timeout
+        """
+        if iteration < 0:
+            raise ValueError(f"iteration must be >= 0, got {iteration}")
+
+        if self.interval == 0:
+            return
+
+        sleep_s = self.interval * (self.backoff ** int(iteration))
+
+        if self.max_interval > 0:
+            sleep_s = min(sleep_s, self.max_interval)
+
+        if sleep_s <= 0:
+            return
+
+        if start is not None and self.timeout > 0:
+            elapsed = time.time() - float(start)
+            remaining = self.timeout - elapsed
+            if remaining <= 0:
+                raise TimeoutError(f"Timed out waiting after {self.timeout:.3f}s")
+            sleep_s = min(sleep_s, remaining)
+
+        if sleep_s <= 0:
+            return
+
+        time.sleep(sleep_s)
+
+
+DEFAULT_WAITING_CONFIG = WaitingConfig()

yggdrasil/types/cast/arrow_cast.py

@@ -26,6 +26,9 @@ __all__ = [
     "to_spark_arrow_type",
     "to_polars_arrow_type",
     "arrow_field_to_schema",
+    "is_arrow_type_binary_like",
+    "is_arrow_type_string_like",
+    "is_arrow_type_list_like",
 ]
 
 logger = logging.getLogger(__name__)