ygg 0.1.32__py3-none-any.whl → 0.1.34__py3-none-any.whl

yggdrasil/databricks/workspaces/workspace.py

@@ -330,6 +330,12 @@ class Workspace:
         if local_cache:
             os.remove(local_cache)
 
+    @property
+    def safe_host(self):
+        if not self.host:
+            return self.connect().host
+        return self.host
+
     @property
     def current_user(self):
         """Return the current Databricks user.
@@ -625,7 +631,12 @@ class Workspace:
         """
         from ..compute.cluster import Cluster
 
-        return Cluster(workspace=self, cluster_id=cluster_id, cluster_name=cluster_name, **kwargs)
+        return Cluster(
+            workspace=self,
+            cluster_id=cluster_id,
+            cluster_name=cluster_name,
+            **kwargs
+        )
 
 # ---------------------------------------------------------------------------
 # Workspace-bound base class

yggdrasil/pyutils/callable_serde.py

@@ -7,12 +7,13 @@ import dis
 import importlib
 import inspect
 import json
+import os
 import struct
 import sys
 import zlib
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, Callable, Dict, Optional, Set, Tuple, TypeVar, Union
+from typing import Any, Callable, Dict, Optional, Set, Tuple, TypeVar, Union, Iterable
 
 import dill
 
@@ -378,6 +379,8 @@ class CallableSerde:
         prefer: str = "import",          # "import" | "dill"
         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,
     ) -> Dict[str, Any]:
         """Serialize the callable into a dict for transport.
 
@@ -385,6 +388,8 @@ class CallableSerde:
             prefer: Preferred serialization kind.
             dump_env: Environment payload selection.
             filter_used_globals: Filter globals to referenced names.
+            env_keys: environment keys
+            env_variables: environment key values
 
         Returns:
             Serialized payload dict.
@@ -411,6 +416,17 @@ class CallableSerde:
                 self._dill_b64 = base64.b64encode(payload).decode("ascii")
             out["dill_b64"] = self._dill_b64
 
+        env_variables = env_variables or {}
+        if env_keys:
+            for env_key in env_keys:
+                existing = os.getenv(env_key)
+
+                if existing:
+                    env_variables[env_key] = existing
+
+        if env_variables:
+            out["osenv"] = env_variables
+
         if dump_env != "none":
             if self.fn is None:
                 raise ValueError("dump_env requested but fn is not present.")
@@ -523,6 +539,8 @@ class CallableSerde:
         byte_limit: int = 256_000,
         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,
     ) -> str:
         """
         Returns Python code string to execute in another interpreter.
@@ -536,6 +554,8 @@ class CallableSerde:
             prefer=prefer,
             dump_env=dump_env,
             filter_used_globals=filter_used_globals,
+            env_keys=env_keys,
+            env_variables=env_variables
         )
         serde_json = json.dumps(serde_dict, ensure_ascii=False)
 
@@ -545,7 +565,7 @@ class CallableSerde:
 
         # NOTE: plain string template + replace. No f-string. No brace escaping.
         template = r"""
-import base64, json, sys, struct, zlib, importlib, dis
+import base64, json, sys, struct, zlib, importlib, dis, os
 import dill
 
 RESULT_TAG = __RESULT_TAG__
@@ -626,6 +646,11 @@ else:
     else:
         fn = dill.loads(base64.b64decode(serde["dill_b64"]))
 
+osenv = serde.get("osenv")
+if osenv:
+    for k, v in osenv.items():
+        os.environ[k] = v
+
 env_b64 = serde.get("env_b64")
 if env_b64:
     env = dill.loads(base64.b64decode(env_b64))

yggdrasil/pyutils/expiring_dict.py

@@ -0,0 +1,176 @@
+from __future__ import annotations
+
+import heapq
+import itertools
+import threading
+import time
+from collections.abc import MutableMapping, Iterator
+from dataclasses import dataclass
+from typing import Callable, Generic, Optional, TypeVar, Dict, Tuple
+
+K = TypeVar("K")
+V = TypeVar("V")
+
+
+__all__ = [
+    "ExpiringDict"
+]
+
+
+@dataclass(frozen=True)
+class _Entry(Generic[V]):
+    value: V
+    expires_at: float  # monotonic timestamp
+
+
+class ExpiringDict(MutableMapping[K, V]):
+    """
+    Dict with per-key TTL expiration.
+
+    - Uses time.monotonic() (safe against system clock changes)
+    - O(log n) cleanup amortized via a min-heap of expirations
+    - Overwrites are handled (stale heap entries are ignored)
+    - Optional refresh_on_get: touching a key extends its TTL
+    """
+
+    def __init__(
+        self,
+        default_ttl: Optional[float] = None,
+        *,
+        refresh_on_get: bool = False,
+        on_expire: Optional[Callable[[K, V], None]] = None,
+        thread_safe: bool = False,
+    ) -> None:
+        """
+        default_ttl: seconds, if provided used when ttl isn't passed to set()
+        refresh_on_get: if True, get()/__getitem__ extends TTL using default_ttl
+        on_expire: callback(key, value) called when an item is expired during cleanup
+        thread_safe: wrap operations in an RLock (extra overhead, but safe)
+        """
+        self.default_ttl = default_ttl
+        self.refresh_on_get = refresh_on_get
+        self.on_expire = on_expire
+
+        self._store: Dict[K, _Entry[V]] = {}
+        self._heap: list[Tuple[float, int, K]] = []  # (expires_at, seq, key)
+        self._seq = itertools.count()
+
+        self._lock = threading.RLock() if thread_safe else None
+
+    def _now(self) -> float:
+        return time.monotonic()
+
+    def _with_lock(self):
+        # tiny helper to avoid repeating if/else everywhere
+        return self._lock or _NoopLock()
+
+    def _prune(self) -> None:
+        """Remove expired entries. Ignores stale heap rows from overwrites."""
+        now = self._now()
+        while self._heap and self._heap[0][0] <= now:
+            exp, _, key = heapq.heappop(self._heap)
+            entry = self._store.get(key)
+            if entry is None:
+                continue
+            # Only expire if this heap expiry matches current entry expiry
+            if entry.expires_at == exp:
+                del self._store[key]
+                if self.on_expire:
+                    self.on_expire(key, entry.value)
+
+    def set(self, key: K, value: V, ttl: Optional[float] = None) -> None:
+        with self._with_lock():
+            self._prune()
+            if ttl is None:
+                ttl = self.default_ttl
+            if ttl is None:
+                # no expiration
+                expires_at = float("inf")
+            else:
+                if ttl <= 0:
+                    # immediate expiration: just delete if exists
+                    self._store.pop(key, None)
+                    return
+                expires_at = self._now() + ttl
+
+            self._store[key] = _Entry(value=value, expires_at=expires_at)
+            heapq.heappush(self._heap, (expires_at, next(self._seq), key))
+
+    # --- MutableMapping interface ---
+    def __setitem__(self, key: K, value: V) -> None:
+        # Uses default_ttl (if any)
+        self.set(key, value, ttl=self.default_ttl)
+
+    def __getitem__(self, key: K) -> V:
+        with self._with_lock():
+            self._prune()
+            entry = self._store[key]  # may raise KeyError
+            if entry.expires_at <= self._now():
+                # edge case: expired but not yet pruned (rare)
+                del self._store[key]
+                raise KeyError(key)
+
+            if self.refresh_on_get:
+                if self.default_ttl is None:
+                    raise ValueError("refresh_on_get=True requires default_ttl")
+                # refresh TTL
+                self.set(key, entry.value, ttl=self.default_ttl)
+                return entry.value
+
+            return entry.value
+
+    def get(self, key: K, default: Optional[V] = None) -> Optional[V]:
+        try:
+            return self[key]
+        except KeyError:
+            return default
+
+    def __delitem__(self, key: K) -> None:
+        with self._with_lock():
+            self._prune()
+            del self._store[key]
+            # heap keeps stale rows; they'll be ignored during prune
+
+    def __iter__(self) -> Iterator[K]:
+        with self._with_lock():
+            self._prune()
+            return iter(list(self._store.keys()))
+
+    def __len__(self) -> int:
+        with self._with_lock():
+            self._prune()
+            return len(self._store)
+
+    def __contains__(self, key: object) -> bool:
+        with self._with_lock():
+            self._prune()
+            if key in self._store:
+                entry = self._store[key]  # type: ignore[index]
+                return entry.expires_at > self._now()
+            return False
+
+    def cleanup(self) -> int:
+        """Force prune and return number of remaining items."""
+        with self._with_lock():
+            self._prune()
+            return len(self._store)
+
+    def items(self):
+        with self._with_lock():
+            self._prune()
+            return [(k, e.value) for k, e in self._store.items()]
+
+    def keys(self):
+        with self._with_lock():
+            self._prune()
+            return list(self._store.keys())
+
+    def values(self):
+        with self._with_lock():
+            self._prune()
+            return [e.value for e in self._store.values()]
+
+
+class _NoopLock:
+    def __enter__(self): return self
+    def __exit__(self, exc_type, exc, tb): return False

yggdrasil/version.py

@@ -1 +1 @@
-__version__ = "0.1.32"
+__version__ = "0.1.34"