ygg 0.1.57__py3-none-any.whl → 0.1.64__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/modules.py

@@ -42,7 +42,7 @@ MODULE_PROJECT_NAMES_ALIASES = {
     "yggdrasil": "ygg",
     "jwt": "PyJWT",
 }
-
+DEFAULT_PIP_INDEX_SETTINGS = None
 
 def module_name_to_project_name(module_name: str) -> str:
     """Map module import names to PyPI project names when they differ.
@@ -264,6 +264,11 @@ class PipIndexSettings:
         Returns:
             Default PipIndexSettings instance.
         """
+        global DEFAULT_PIP_INDEX_SETTINGS
+
+        if DEFAULT_PIP_INDEX_SETTINGS is None:
+            DEFAULT_PIP_INDEX_SETTINGS = get_pip_index_settings()
+
         return DEFAULT_PIP_INDEX_SETTINGS
 
     @property
@@ -363,9 +368,3 @@ def get_pip_index_settings() -> PipIndexSettings:
             extra_index_urls.append(u)
 
     return PipIndexSettings(index_url=index_url, extra_index_urls=extra_index_urls, sources=sources)
-
-
-try:
-    DEFAULT_PIP_INDEX_SETTINGS = get_pip_index_settings()
-except:
-    DEFAULT_PIP_INDEX_SETTINGS = PipIndexSettings()

yggdrasil/pyutils/python_env.py

@@ -20,14 +20,13 @@ from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any, Iterable, Iterator, Mapping, MutableMapping, Optional, Union, List, Tuple
 
-from yggdrasil.pyutils.modules import PipIndexSettings
+from .modules import PipIndexSettings
 
 log = logging.getLogger(__name__)
 
 
 class PythonEnvError(RuntimeError):
     """Raised when Python environment operations fail."""
-
     pass
 
 
@@ -72,6 +71,9 @@ _NON_PIPABLE_RE = re.compile(
     re.IGNORECASE,
 )
 
+# Snapshot singleton (import-time)
+CURRENT_PYTHON_ENV: "PythonEnv" = None
+
 
 
 def _filter_non_pipable_linux_packages(requirements: Iterable[str]) -> List[str]:
@@ -441,19 +443,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(
@@ -1507,11 +1510,3 @@ print("RESULT:" + json.dumps(top_level))""".strip()
             log.error("python_env CLI error: %s", e)
             print(f"ERROR: {e}", file=sys.stderr)
             return 2
-
-
-# Snapshot singleton (import-time)
-CURRENT_PYTHON_ENV: PythonEnv = PythonEnv.get_current()
-
-
-if __name__ == "__main__":
-    raise SystemExit(PythonEnv.cli())

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/requests/msal.py

@@ -3,12 +3,8 @@
 # auth_session.py
 import os
 import time
-from typing import Any, Mapping, Optional
-
-import urllib3
-
-urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
-from dataclasses import dataclass
+from dataclasses import dataclass, field
+from typing import Any, Optional
 
 from .session import YGGSession
 
@@ -38,11 +34,11 @@ class MSALAuth:
         authority: Optional authority URL override.
         scopes: List of scopes to request.
     """
-    tenant_id: Optional[str] = None
-    client_id: Optional[str] = None
-    client_secret: Optional[str] = None
-    authority: Optional[str] = None
-    scopes: list[str] | None = None
+    tenant_id: Optional[str] = field(default_factory=lambda: os.environ.get("AZURE_TENANT_ID"))
+    client_id: Optional[str] = field(default_factory=lambda: os.environ.get("AZURE_CLIENT_ID"))
+    client_secret: Optional[str] = field(default_factory=lambda: os.environ.get("AZURE_CLIENT_SECRET"))
+    authority: Optional[str] = field(default_factory=lambda: os.environ.get("AZURE_AUTHORITY"))
+    scopes: list[str] | None = field(default_factory=lambda: os.environ.get("AZURE_SCOPES"))
 
     _auth_app: ConfidentialClientApplication | None = None
     _expires_at: float | None = None
@@ -77,97 +73,15 @@ class MSALAuth:
         Returns:
             None.
         """
-        self.tenant_id = self.tenant_id or os.environ.get("AZURE_TENANT_ID")
-        self.client_id = self.client_id or os.environ.get("AZURE_CLIENT_ID")
-        self.client_secret = self.client_secret or os.environ.get("AZURE_CLIENT_SECRET")
-
-        self.authority = self.authority or os.environ.get("AZURE_AUTHORITY")
         if not self.authority:
+            assert self.tenant_id, "tenant_id is required to build authority URL"
+
             self.authority = f"https://login.microsoftonline.com/{self.tenant_id}"
 
-        self.scopes = self.scopes or os.environ.get("AZURE_SCOPES")
         if self.scopes:
             if isinstance(self.scopes, str):
                 self.scopes = self.scopes.split(",")
 
-        self._validate_config()
-
-    def _validate_config(self):
-        """Validate that all required configuration is present.
-
-        Returns:
-            None.
-        """
-        missing = []
-
-        if not self.client_id:
-            missing.append("azure_client_id (AZURE_CLIENT_ID)")
-        if not self.client_secret:
-            missing.append("azure_client_secret (AZURE_CLIENT_SECRET)")
-        if not self.tenant_id:
-            missing.append("azure_client_secret (AZURE_TENANT_ID)")
-        if not self.scopes:
-            missing.append("scopes (AZURE_SCOPES)")
-
-        if missing:
-            raise ValueError(f"Missing required configuration: {', '.join(missing)}")
-
-    @classmethod
-    def find_in_env(
-        cls,
-        env: Mapping = None,
-        prefix: Optional[str] = None
-    ) -> "MSALAuth":
-        """Return an MSALAuth built from environment variables if available.
-
-        Args:
-            env: Mapping to read variables from; defaults to os.environ.
-            prefix: Optional prefix for variable names.
-
-        Returns:
-            A configured MSALAuth instance or None.
-        """
-        if not env:
-            env = os.environ
-        prefix = prefix or "AZURE_"
-
-        required = {
-            key: env.get(prefix + key.upper())
-            for key in (
-                "client_id", "client_secret", "tenant_id", "scopes"
-            )
-        }
-
-        if all(required.values()):
-            scopes = required["scopes"].split(",") if required["scopes"] else None
-            return MSALAuth(
-                tenant_id=required["tenant_id"],
-                client_id=required["client_id"],
-                client_secret=required["client_secret"],
-                scopes=scopes,
-                authority=env.get(prefix + "AUTHORITY"),
-            )
-
-        return None
-
-    def export_to(self, to: dict = os.environ):
-        """Export the auth configuration to the provided mapping.
-
-        Args:
-            to: Mapping to populate with auth configuration values.
-
-        Returns:
-            None.
-        """
-        for key, value in (
-            ("AZURE_CLIENT_ID", self.client_id),
-            ("AZURE_CLIENT_SECRET", self.client_secret),
-            ("AZURE_AUTHORITY", self.authority),
-            ("AZURE_SCOPES", ",".join(self.scopes)),
-        ):
-            if value:
-                to[key] = value
-
     @property
     def auth_app(self) -> ConfidentialClientApplication:
         """Return or initialize the MSAL confidential client.
@@ -298,7 +212,6 @@ class MSALSession(YGGSession):
         super().__init__(*args, **kwargs)
         self.msal_auth = msal_auth
 
-
     def prepare_request(self, request):
         """Prepare the request with an Authorization header when needed.
 

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__)