langfun 0.1.2.dev202510280805__py3-none-any.whl → 0.1.2.dev202510300805__py3-none-any.whl

langfun/env/interface.py

@@ -17,8 +17,9 @@ import abc
 import contextlib
 import dataclasses
 import enum
+import functools
 import os
-from typing import Annotated, Any, ContextManager, ClassVar, Iterator, Optional
+from typing import Annotated, Any, Callable, ContextManager, ClassVar, Iterator, Optional, Sequence, Type
 
 import pyglove as pg
 
@@ -170,6 +171,9 @@ class SessionTeardownError(SandboxError):
 class Environment(pg.Object):
   """Base class for an environment."""
 
+  # Disable symbolic comparison and hashing for environment objects.
+  use_symbolic_comparison = False
+
   @dataclasses.dataclass(frozen=True)
   class Id:
     """Identifier for an environment."""
@@ -220,6 +224,20 @@ class Environment(pg.Object):
   def id(self) -> Id:
     """Returns the identifier for the environment."""
 
+  @property
+  @abc.abstractmethod
+  def image_ids(self) -> list[str]:
+    """Returns the non-dynamic image IDs served by the environment."""
+
+  def image_id_for(self, feature: 'Feature') -> str:
+    """Returns the default image ID for the environment."""
+    for image_id in self.image_ids:
+      if feature.is_applicable(image_id):
+        return image_id
+    raise ValueError(
+        f'No image ID found for feature {feature.name} in {self.image_ids}.'
+    )
+
   @property
   @abc.abstractmethod
   def status(self) -> Status:
@@ -245,9 +263,16 @@ class Environment(pg.Object):
     """
 
   @abc.abstractmethod
-  def acquire(self) -> 'Sandbox':
+  def acquire(
+      self,
+      image_id: str | None = None,
+  ) -> 'Sandbox':
     """Acquires a free sandbox from the environment.
 
+    Args:
+      image_id: The image ID to use for the sandbox. If None, it will be
+        automatically determined by the environment.
+
     Returns:
       A free sandbox from the environment.
 
@@ -257,7 +282,7 @@ class Environment(pg.Object):
     """
 
   @abc.abstractmethod
-  def new_session_id(self) -> str:
+  def new_session_id(self, feature_hint: str | None = None) -> str:
     """Generates a new session ID."""
 
   #
@@ -298,33 +323,63 @@ class Environment(pg.Object):
 
   def sandbox(
       self,
+      image_id: str | None = None,
       session_id: str | None = None,
   ) -> ContextManager['Sandbox']:
     """Gets a sandbox from the environment and starts a new user session."""
-    return self.acquire().new_session(session_id)
+    return self.acquire(image_id=image_id).new_session(session_id)
 
   def __getattr__(self, name: str) -> Any:
-    """Gets a feature from a free sandbox from the environment.
+    """Gets a feature session from a free sandbox from the environment.
 
     Example:
       ```
       with XboxEnvironment(
           features={'selenium': SeleniumFeature()}
       ) as env:
-        driver = env.selenium.get_driver()
+        with env.selenium() as selenium:
+          driver = selenium.get_driver()
       ```
 
     Args:
       name: The name of the feature.
 
     Returns:
-      A feature from a free sandbox from the environment.
+      A callable `(image_id, *, session_id) -> ContextManager[Feature]` that
+      creates a context manager for the requested feature under a new client
+      session.
     """
     if name in self.features:
-      return self.acquire().features[name]
+      return _feature_session_creator(self, self.features[name])
     raise AttributeError(name)
 
 
+@contextlib.contextmanager
+def _session_for_feature(
+    environment: Environment,
+    feature: 'Feature',
+    image_id: str | None = None,
+    session_id: str | None = None,
+) -> Iterator['Feature']:
+  """Returns a context manager for a session for a feature."""
+  if image_id is None:
+    image_id = environment.image_id_for(feature)
+  elif not feature.is_applicable(image_id):
+    raise ValueError(
+        f'Feature {feature.name!r} is not applicable to image {image_id!r}.'
+    )
+  sandbox = environment.acquire(image_id=image_id)
+  with sandbox.new_session(session_id=session_id, feature_hint=feature.name):
+    yield sandbox.features[feature.name]
+
+
+def _feature_session_creator(environment: Environment, feature: 'Feature'):
+  """Returns a callable that returns a context manager for a feature session."""
+  def fn(image_id: str | None = None, session_id: str | None = None):
+    return _session_for_feature(environment, feature, image_id, session_id)
+  return fn
+
+
 # Enable automatic conversion from str to Environment.Id.
 pg.typing.register_converter(str, Environment.Id, Environment.Id)
 
@@ -332,14 +387,18 @@ pg.typing.register_converter(str, Environment.Id, Environment.Id)
 class Sandbox(pg.Object):
   """Interface for sandboxes."""
 
+  # Disable symbolic comparison and hashing for sandbox objects.
+  use_symbolic_comparison = False
+
   @dataclasses.dataclass(frozen=True, slots=True)
   class Id:
     """Identifier for a sandbox."""
     environment_id: Environment.Id
+    image_id: str
     sandbox_id: str
 
     def __str__(self) -> str:
-      return f'{self.environment_id}/{self.sandbox_id}'
+      return f'{self.environment_id}/{self.image_id}:{self.sandbox_id}'
 
     def working_dir(self, root_dir: str | None) -> str | None:
       """Returns the download directory for the sandbox."""
@@ -347,6 +406,7 @@ class Sandbox(pg.Object):
         return None
       return os.path.join(
           self.environment_id.working_dir(root_dir),
+          _make_path_compatible(self.image_id),
           _make_path_compatible(self.sandbox_id)
       )
 
@@ -438,6 +498,11 @@ class Sandbox(pg.Object):
   def id(self) -> Id:
     """Returns the identifier for the sandbox."""
 
+  @property
+  @abc.abstractmethod
+  def image_id(self) -> str:
+    """Returns the image ID used for bootstrapping the sandbox."""
+
   @property
   @abc.abstractmethod
   def environment(self) -> Environment:
@@ -458,10 +523,17 @@ class Sandbox(pg.Object):
     """Returns True if the sandbox is online."""
     return self.status.is_online
 
-  @property
   @abc.abstractmethod
-  def state_errors(self) -> list[SandboxStateError]:
-    """Returns state errors encountered during sandbox's lifecycle."""
+  def report_state_error(self, error: SandboxStateError) -> None:
+    """Reports state error the sandbox.
+
+    If state errors are reported, the sandbox will be forcefully shutdown when
+    `Sandbox.end_session()` is called, even if the sandbox is set to be
+    reusable.
+
+    Args:
+      error: SandboxStateError to report.
+    """
 
   @abc.abstractmethod
   def start(self) -> None:
@@ -592,6 +664,9 @@ class Sandbox(pg.Object):
     `end_session` should always be called for each `start_session` call, even
     when the session fails to start, to ensure proper cleanup.
 
+    When `end_session` is called with state errors reported, the sandbox will be
+    forcefully shutdown even if the sandbox is set to be reusable.
+
     `end_session` may fail with two sources of errors:
 
     1. SandboxStateError: If the sandbox is in a bad state or session teardown
@@ -615,6 +690,24 @@ class Sandbox(pg.Object):
   def session_id(self) -> str | None:
     """Returns the current user session identifier."""
 
+  @abc.abstractmethod
+  def track_activity(
+      self,
+      name: str,
+      feature: Optional['Feature'] = None,
+      **kwargs: Any
+  ) -> ContextManager[None]:
+    """Context manager that tracks a sandbox activity.
+
+    Args:
+      name: The name of the activity.
+      feature: The feature that the activity is associated with.
+      **kwargs: Additional keyword arguments to pass to the activity handler.
+
+    Returns:
+      A context manager that tracks the activity, including duration and error.
+    """
+
   #
   # API related to a user session.
   # A sandbox could be reused across different user sessions.
@@ -626,6 +719,8 @@ class Sandbox(pg.Object):
   def new_session(
       self,
       session_id: str | None = None,
+      *,
+      feature_hint: str | None = None,
   ) -> Iterator['Sandbox']:
     """Context manager for obtaining a sandbox for a user session.
 
@@ -636,6 +731,9 @@ class Sandbox(pg.Object):
     Args:
       session_id: The identifier for the user session. If not provided, a random
         ID will be generated.
+      feature_hint: A hint of which feature is the main user intent when
+        starting the session. This is used for generating the session id if
+        `session_id` is not provided.
 
     Yields:
       The sandbox for the user session.
@@ -646,10 +744,13 @@ class Sandbox(pg.Object):
         errors.
     """
     if session_id is None:
-      session_id = self.environment.new_session_id()
+      session_id = self.environment.new_session_id(feature_hint)
     self.start_session(session_id)
     try:
       yield self
+    except SandboxStateError as e:
+      self.report_state_error(e)
+      raise
     finally:
       self.end_session()
 
@@ -683,6 +784,9 @@ class Sandbox(pg.Object):
 class Feature(pg.Object):
   """Interface for sandbox features."""
 
+  # Disable symbolic comparison and hashing for sandbox objects.
+  allow_symbolic_comparison = False
+
   @property
   @abc.abstractmethod
   def name(self) -> str:
@@ -700,6 +804,10 @@ class Feature(pg.Object):
       AssertError: If the feature is not set up with a sandbox yet.
     """
 
+  @abc.abstractmethod
+  def is_applicable(self, image_id: str) -> bool:
+    """Returns True if the feature is applicable to the given image."""
+
   @abc.abstractmethod
   def setup(self, sandbox: Sandbox) -> None:
     """Sets up the feature, which is called once when the sandbox is up.
@@ -811,6 +919,12 @@ class Feature(pg.Object):
     assert self.sandbox is not None
     return self.sandbox.session_id
 
+  def track_activity(self, name: str, **kwargs: Any) -> ContextManager[None]:
+    """Context manager that tracks a feature activity."""
+    return self.sandbox.track_activity(
+        f'{self.name}.{name}', feature=self, **kwargs
+    )
+
 
 def _make_path_compatible(id_str: str) -> str:
   """Makes a path compatible with CNS."""
@@ -824,3 +938,73 @@ def _make_path_compatible(id_str: str) -> str:
           '>': '',
       })
   )
+
+
+def treat_as_sandbox_state_error(
+    errors: Sequence[
+        Type[BaseException] | tuple[Type[BaseException], str]
+    ] | None = None
+) -> Callable[..., Any]:
+  """Decorator for Sandbox/Feature methods to convert errors to SandboxStateError.
+
+  Args:
+    errors: A sequence of exception types or tuples of (error_type, msg_regex).
+      when matched, treat the error as SandboxStateError, which will lead to
+      a sandbox shutdown when caught by `Sandbox.new_session()` context manager.
+
+  Returns:
+    The decorator function.
+  """
+
+  def decorator(func):
+    @functools.wraps(func)
+    def method_wrapper(self, *args, **kwargs) -> Any:
+      """Helper function to safely execute logics in the sandbox."""
+
+      assert isinstance(self, (Sandbox, Feature)), self
+      sandbox = self.sandbox if isinstance(self, Feature) else self
+
+      try:
+        # Execute the service function.
+        return func(self, *args, **kwargs)
+      except BaseException as e:
+        if pg.match_error(e, errors):
+          state_error = SandboxStateError(
+              'Sandbox encountered an unexpected error executing '
+              f'`{func.__name__}` (args={args!r}, kwargs={kwargs!r}): {e}',
+              sandbox=sandbox
+          )
+          raise state_error from e
+        raise
+    return method_wrapper
+  return decorator
+
+
+def log_sandbox_activity(name: str | None = None):
+  """Decorator for Sandbox/Feature methods to log sandbox activity."""
+
+  def decorator(func):
+    signature = pg.typing.get_signature(func)
+    def to_kwargs(*args, **kwargs):
+      num_non_self_args = len(signature.arg_names) - 1
+      if len(args) > num_non_self_args:
+        assert signature.varargs is not None, (signature, args)
+        kwargs[signature.varargs.name] = tuple(args[num_non_self_args:])
+        args = args[:num_non_self_args]
+      for i in range(len(args)):
+        # The first argument is `self`.
+        kwargs[signature.arg_names[i + 1]] = args[i]
+      return kwargs
+
+    @functools.wraps(func)
+    def method_wrapper(self, *args, **kwargs) -> Any:
+      """Helper function to safely execute logics in the sandbox."""
+
+      assert isinstance(self, (Sandbox, Feature)), self
+      with self.track_activity(
+          name or func.__name__,
+          **to_kwargs(*args, **kwargs)
+      ):
+        return func(self, *args, **kwargs)
+    return method_wrapper
+  return decorator

langfun/env/interface_test.py

@@ -11,6 +11,8 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+import contextlib
+from typing import Iterator
 import unittest
 from langfun.env import interface
 
@@ -29,15 +31,92 @@ class IdTest(unittest.TestCase):
   def test_sandbox_id(self):
     sandbox_id = interface.Sandbox.Id(
         environment_id=interface.Environment.Id('env'),
+        image_id='image:2025_01_01_00_00_00',
         sandbox_id='sandbox'
     )
-    self.assertEqual(str(sandbox_id), 'env/sandbox')
+    self.assertEqual(str(sandbox_id), 'env/image:2025_01_01_00_00_00:sandbox')
     self.assertEqual(
         sandbox_id.working_dir(root_dir='/tmp'),
-        '/tmp/env/sandbox'
+        '/tmp/env/image_2025_01_01_00_00_00/sandbox'
     )
     self.assertIsNone(sandbox_id.working_dir(root_dir=None))
 
 
+class TestingSandbox(interface.Sandbox):
+
+  id: interface.Sandbox.Id = interface.Sandbox.Id(
+      environment_id=interface.Environment.Id('env'),
+      image_id='test_image',
+      sandbox_id='0:0'
+  )
+  image_id: str = 'test_image'
+  features: dict[str, interface.Feature] = {}
+  status: interface.Sandbox.Status = interface.Sandbox.Status.READY
+  session_id: str | None = None
+
+  def environment(self) -> interface.Environment:
+    pass
+
+  def _on_bound(self) -> None:
+    self.activities = []
+
+  def report_state_error(self, error: interface.SandboxStateError) -> None:
+    pass
+
+  def start(self) -> None:
+    pass
+
+  def shutdown(self) -> None:
+    pass
+
+  def start_session(self, session_id: str) -> None:
+    pass
+
+  def end_session(self, shutdown_sandbox: bool = False) -> None:
+    pass
+
+  @contextlib.contextmanager
+  def track_activity(
+      self,
+      name: str,
+      feature: interface.Feature | None = None,
+      **kwargs
+  ) -> Iterator[None]:
+    error = None
+    try:
+      yield
+    except BaseException as e:
+      error = e
+      raise
+    finally:
+      self.activities.append((name, error, kwargs))
+
+
+class DecoratorTest(unittest.TestCase):
+
+  def test_treat_as_sandbox_state_error(self):
+
+    class SandboxA(TestingSandbox):
+
+      @interface.treat_as_sandbox_state_error(errors=(ValueError,))
+      def foo(self, bar: str) -> None:
+        raise ValueError(bar)
+
+    with self.assertRaises(interface.SandboxStateError):
+      SandboxA().foo('foo')
+
+  def test_log_sandbox_activity(self):
+
+    class SandboxB(TestingSandbox):
+
+      @interface.log_sandbox_activity()
+      def bar(self, x: str) -> None:
+        pass
+
+    sb = SandboxB()
+    sb.bar('foo')
+    self.assertEqual(sb.activities, [('bar', None, {'x': 'foo'})])
+
+
 if __name__ == '__main__':
   unittest.main()

langfun/env/load_balancers_test.py

@@ -12,7 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 import concurrent.futures
+import contextlib
 import time
+from typing import Any, Iterator
 import unittest
 
 from langfun.env import interface
@@ -22,6 +24,7 @@ from langfun.env import load_balancers
 class TestingSandbox(interface.Sandbox):
   sandbox_id: str
   status: interface.Sandbox.Status = interface.Sandbox.Status.READY
+  image_id: str = 'test_image'
 
   def _on_bound(self) -> None:
     super()._on_bound()
@@ -31,6 +34,7 @@ class TestingSandbox(interface.Sandbox):
   def id(self) -> interface.Sandbox.Id:
     return interface.Sandbox.Id(
         environment_id=interface.Environment.Id('testing-env'),
+        image_id=self.image_id,
         sandbox_id=self.sandbox_id
     )
 
@@ -46,6 +50,9 @@ class TestingSandbox(interface.Sandbox):
   def state_errors(self) -> list[interface.SandboxStateError]:
     return []
 
+  def report_state_error(self, error: interface.SandboxStateError) -> None:
+    pass
+
   def set_status(self, status: interface.Sandbox.Status) -> None:
     self.rebind(status=status, skip_notification=True)
 
@@ -68,6 +75,18 @@ class TestingSandbox(interface.Sandbox):
   def session_id(self) -> str | None:
     return self._session_id
 
+  @contextlib.contextmanager
+  def track_activity(
+      self,
+      name: str,
+      feature: interface.Feature | None = None,
+      **kwargs: Any
+  ) -> Iterator[None]:
+    try:
+      yield
+    finally:
+      pass
+
 
 class RoundRobinTest(unittest.TestCase):
 

langfun/env/test_utils.py

@@ -27,7 +27,7 @@ import pyglove as pg
 
 class TestingEnvironment(base_environment.BaseEnvironment):
   """Testing environment for unit tests."""
-
+  image_ids: list[str] = ['test_image']
   housekeep_interval: float = 0.0
   simulate_start_error: Type[BaseException] | None = None
   simulate_shutdown_error: Type[BaseException] | None = None
@@ -45,6 +45,7 @@ class TestingEnvironment(base_environment.BaseEnvironment):
 
   def _create_sandbox(
       self,
+      image_id: str,
       sandbox_id: str,
       reusable: bool,
       proactive_session_setup: bool,
@@ -54,8 +55,10 @@ class TestingEnvironment(base_environment.BaseEnvironment):
         environment=self,
         id=interface.Sandbox.Id(
             environment_id=self.id,
+            image_id=image_id,
             sandbox_id=sandbox_id
         ),
+        image_id=image_id,
         reusable=reusable,
         proactive_session_setup=proactive_session_setup,
         keepalive_interval=keepalive_interval,
@@ -109,7 +112,8 @@ class TestingSandbox(base_sandbox.BaseSandbox):
       self._raise_error('Sandbox shutdown error', self.simulate_shutdown_error)
     super()._shutdown()
 
-  @base_sandbox.sandbox_service(critical_errors=(RuntimeError,))
+  @interface.treat_as_sandbox_state_error(errors=(RuntimeError,))
+  @interface.log_sandbox_activity()
   def shell(
       self,
       code: str,
@@ -181,19 +185,19 @@ class TestingFeature(base_feature.BaseFeature):
     if self.call_end_session_on_teardown_session:
       self.sandbox.end_session()
 
-  @base_sandbox.sandbox_service()
+  @interface.log_sandbox_activity()
   def num_shell_calls(self) -> int:
     return len(self.sandbox._shell_history)  # pylint: disable=protected-access
 
-  @base_sandbox.sandbox_service()
+  @interface.log_sandbox_activity()
   def bad_shell_call(self) -> None:
     self.sandbox.shell('bad command', raise_error=RuntimeError)
 
-  @base_sandbox.sandbox_service()
+  @interface.log_sandbox_activity()
   def show_session_id(self):
     return self.session_id
 
-  @base_sandbox.sandbox_service()
+  @interface.log_sandbox_activity()
   def call_with_varargs(self, code: str, *args, **kwargs):
     del code, args, kwargs
     return 0
@@ -202,7 +206,6 @@ class TestingFeature(base_feature.BaseFeature):
     super()._on_bound()
     self._service = None
 
-  @base_sandbox.sandbox_service()
   @contextlib.contextmanager
   def my_service(self) -> Iterator[Service]:
     try:

{langfun-0.1.2.dev202510280805.dist-info → langfun-0.1.2.dev202510300805.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langfun
-Version: 0.1.2.dev202510280805
+Version: 0.1.2.dev202510300805
 Summary: Langfun: Language as Functions.
 Home-page: https://github.com/google/langfun
 Author: Langfun Authors

{langfun-0.1.2.dev202510280805.dist-info → langfun-0.1.2.dev202510300805.dist-info}/RECORD

@@ -35,10 +35,10 @@ langfun/core/subscription_test.py,sha256=Y4ZdbZEwm83YNZBxHff0QR4QUa4rdaNXA3_jfIc
 langfun/core/template.py,sha256=CQOEA1Lq0gU_uk43K1FJjpBSwL8o5fglFr2tGCbOxpI,26008
 langfun/core/template_test.py,sha256=vQZvFVS4VHk-6GUdOEQ-UA_4tlVBbpRPqB1Bw7DFJJg,19052
 langfun/core/agentic/__init__.py,sha256=vsnuvjaz9-nysBjdihGf43JC8AyLPhPJwIOevyONyAQ,1517
-langfun/core/agentic/action.py,sha256=ojwaPIV_a_khKPR6x1Fk5i2dsUTSe3VjKaxnZ92b0nE,58243
+langfun/core/agentic/action.py,sha256=Zz-17gegJxzCZ9hcOhv-atJX1EfIN-vHonS6z99Bllc,59523
 langfun/core/agentic/action_eval.py,sha256=YTilyUEkJl_8FVMgdfO17PurWWaEJ6oA15CuefJJRLk,4887
 langfun/core/agentic/action_eval_test.py,sha256=7AkOwNbUX-ZgR1R0a7bvUZ5abNTUV7blf_8Mnrwb-II,2811
-langfun/core/agentic/action_test.py,sha256=a2D4FOuob7MviuPZR2Wy6xNKnjlTLxhK8HUy8WIyt08,19076
+langfun/core/agentic/action_test.py,sha256=4X11bNffNZG8WfjB1Z-Sm33Z2hs0YPzz-6ct77V8M7Q,19824
 langfun/core/coding/__init__.py,sha256=5utju_fwEsImaiftx4oXKl9FAM8p281k8-Esdh_-m1w,835
 langfun/core/coding/python/__init__.py,sha256=yTXm92oLpQb4A-fZ2qy-bzfhPYND7B-oidtbv1PNaX0,1678
 langfun/core/coding/python/correction.py,sha256=4PD76Xfv36Xrm8Ji3-GgGDNImtcDqWfMw3z6ircJMlM,7285
@@ -101,7 +101,7 @@ langfun/core/llms/deepseek.py,sha256=Pyv2Pmviu91HfNGR994Mh7AKNvWHAAlue7Xfb9MZaPo
 langfun/core/llms/deepseek_test.py,sha256=DvROWPlDuow5E1lfoSkhyGt_ELA19JoQoDsTnRgDtTg,1847
 langfun/core/llms/fake.py,sha256=bDk_4u7V2LmYUotyOaicwzi0-lnWOIIBbR3-Bil1P3o,3481
 langfun/core/llms/fake_test.py,sha256=lC-C2TpEsnf2kmZpa3OiH2H944I4hMWTAaHEXzRj1DU,7855
-langfun/core/llms/gemini.py,sha256=-DL5PebzaTjz7rTFw_1RC5O1aE4EYSv3oNsM65YKCoo,30143
+langfun/core/llms/gemini.py,sha256=Bsd9UmI-Z6j_ZJposExuh7ChCt1ZF2QE1nWPWHaE39k,30204
 langfun/core/llms/gemini_test.py,sha256=y1s0W65SrdepbZxzgIeoTB2MI7sXnfBDf1NsGn57LbM,7617
 langfun/core/llms/google_genai.py,sha256=ogyoOUK4s1OcSFKun0YK5xBRDVyxmvz9WsYNKAwuB0g,5918
 langfun/core/llms/google_genai_test.py,sha256=NKNtpebArQ9ZR7Qsnhd2prFIpMjleojy6o6VMXkJ1zY,1502
@@ -174,24 +174,24 @@ langfun/core/templates/demonstration.py,sha256=vCrgYubdZM5Umqcgp8NUVGXgr4P_c-fik
 langfun/core/templates/demonstration_test.py,sha256=SafcDQ0WgI7pw05EmPI2S4v1t3ABKzup8jReCljHeK4,2162
 langfun/core/templates/selfplay.py,sha256=yhgrJbiYwq47TgzThmHrDQTF4nDrTI09CWGhuQPNv-s,2273
 langfun/core/templates/selfplay_test.py,sha256=Ot__1P1M8oJfoTp-M9-PQ6HUXqZKyMwvZ5f7yQ3yfyM,2326
-langfun/env/__init__.py,sha256=m6Y8y16ms9lytvO_r-Br8HmTp2rNDhb3R6JJaH5dEEk,1491
-langfun/env/base_environment.py,sha256=m7IJNHqt4dlgBRwv0E8BxKtARvcNJis9FrrALguzX1E,19472
-langfun/env/base_feature.py,sha256=gGUCWLcSaQZ7MoXNKogXEdcpfoqJxcfnoXhWQjqi8jk,6462
-langfun/env/base_sandbox.py,sha256=yG_4qG5MVIEP5uyXO2KssZFSFDewwNvF7Hr_qE7yGfQ,37301
-langfun/env/base_test.py,sha256=DrBtyweO4v8Fz3Oz-gnpJ4W_9hRhuVXA1CTLvXJDa9s,61099
-langfun/env/interface.py,sha256=2Amf-_op7dGRF8c4-wYxcFxs1UCBYz1AB20Lk7__V4E,25724
-langfun/env/interface_test.py,sha256=hfQn4RRTEo1YfVHXTPzH1puzD14BTo8R_5v1IpXVZ90,1398
+langfun/env/__init__.py,sha256=VTjLmS_SkxtkBCmr6hBb4iACeLLPmcbWJkK7MEXsATA,1652
+langfun/env/base_environment.py,sha256=8Cpwb4D37zHj5AK4qgmGIPyxIMEDxTIPHXqxTSNkE_M,25030
+langfun/env/base_feature.py,sha256=JDEhL9LkbBHB0c603guchry7cy_zaIReg5vqExyQQgg,6902
+langfun/env/base_sandbox.py,sha256=0dduNozBtPqawvSX-pv6sEweDNTi89lrT_5qKk5FWak,30656
+langfun/env/base_test.py,sha256=6yHtExP3Soa-l0ug73ZSV9ZfS0B4vu-uaS_K_xvsDwk,74261
+langfun/env/interface.py,sha256=2X-gGD41cnejde5DIQ7QxgW3r85oKP4Gp0iWP-ABmLM,32126
+langfun/env/interface_test.py,sha256=d8vdXL1PkrNQGwzfEI2r6esd6SBnTMgc-3GNArsnuj4,3295
 langfun/env/load_balancers.py,sha256=qRhCthqzjZIQBwta8qC1C0s0J-VQAVomJQqI7Nqv-r4,1948
-langfun/env/load_balancers_test.py,sha256=73QQG-Lufy5DBhQuzWNUaaH24YiZFdZEHe67TkJn7a0,3708
-langfun/env/test_utils.py,sha256=rnIQZ2ZpiFuB7yfl5ckGtacBoySAwguzBzXzqhyo8jw,14042
+langfun/env/load_balancers_test.py,sha256=Bg0h-AL7LpWb_aixFXs_FpgQp4dWLvodcsQj-mys6zs,4125
+langfun/env/test_utils.py,sha256=9fqhxxKERiyAte9bbtwqXqZ1ihNGyuOdCiPPY8G0I8w,14171
 langfun/env/event_handlers/__init__.py,sha256=H34n-TbKSgtxqBhE-yAti8fY6weF2_v3yw59M9_zmGM,443
 langfun/env/event_handlers/base.py,sha256=eGdJ6N5em9kX-c9wzm1TdnRP5_5IAltX5JTHILdjzLM,10124
 langfun/env/event_handlers/event_logger.py,sha256=3dbPjBe53dBgntYHlyLlj_77hVecPSXkmKeiGXMxlO0,12699
-langfun/env/event_handlers/event_logger_test.py,sha256=PGof3rPllNnyzs3Yp8kaOHLeTkVrzUgCJwlODTrVRKI,9111
-langfun/env/event_handlers/metric_writer.py,sha256=NgJKsd6xWOtEd0IjYi7coGEaqGYkkPcDjXN9CQ3vxPU,18043
-langfun/env/event_handlers/metric_writer_test.py,sha256=deqCIdo-Q89rRCF2lerU3GpWmFG_SvDx162UQIZxPgE,5338
-langfun-0.1.2.dev202510280805.dist-info/licenses/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
-langfun-0.1.2.dev202510280805.dist-info/METADATA,sha256=MGrbvXO1FXOqziKIPFJanHl1OImCc7gDu2_222FTCLY,7522
-langfun-0.1.2.dev202510280805.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-langfun-0.1.2.dev202510280805.dist-info/top_level.txt,sha256=RhlEkHxs1qtzmmtWSwYoLVJAc1YrbPtxQ52uh8Z9VvY,8
-langfun-0.1.2.dev202510280805.dist-info/RECORD,,
+langfun/env/event_handlers/event_logger_test.py,sha256=ryupxaEP9D8wdtSsSwZRSZwqFaHCaSD-bFSea_T7QJo,9133
+langfun/env/event_handlers/metric_writer.py,sha256=F_Gk1lpJX5SZ6-Hyrf_-utf4gvSKvMmcov8VkKogZCU,19618
+langfun/env/event_handlers/metric_writer_test.py,sha256=sntUifTPHGixUshIgVBX4Q9vJL-xbeS0Cpd5X5hSQyQ,5955
+langfun-0.1.2.dev202510300805.dist-info/licenses/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
+langfun-0.1.2.dev202510300805.dist-info/METADATA,sha256=mKbGN2kywExiipSgV10M59iPfOncuioqSZ-9BDa2zRo,7522
+langfun-0.1.2.dev202510300805.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+langfun-0.1.2.dev202510300805.dist-info/top_level.txt,sha256=RhlEkHxs1qtzmmtWSwYoLVJAc1YrbPtxQ52uh8Z9VvY,8
+langfun-0.1.2.dev202510300805.dist-info/RECORD,,