android-env 1.2.2__py3-none-any.whl → 1.2.3__py3-none-any.whl

android_env/components/simulators/emulator/emulator_simulator_test.py

@@ -1,5 +1,5 @@
 # coding=utf-8
-# Copyright 2023 DeepMind Technologies Limited.
+# Copyright 2024 DeepMind Technologies Limited.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -23,6 +23,7 @@ from unittest import mock
 from absl.testing import absltest
 from android_env.components import adb_call_parser
 from android_env.components import adb_controller
+from android_env.components import config_classes
 from android_env.components.simulators.emulator import emulator_launcher
 from android_env.components.simulators.emulator import emulator_simulator
 from android_env.proto import state_pb2
@@ -74,28 +75,32 @@ class EmulatorSimulatorTest(absltest.TestCase):
         return_value=self._launcher).start()
 
   def test_adb_device_name_not_empty(self):
-    tmp_dir = absltest.get_default_test_tmpdir()
-    simulator = emulator_simulator.EmulatorSimulator(
-        tmp_dir=tmp_dir,
-        emulator_launcher_args={'grpc_port': 1234},
-        adb_controller_args={
-            'adb_path': '/my/adb',
-            'adb_server_port': 5037,
-        })
+    config = config_classes.EmulatorConfig(
+        emulator_launcher=config_classes.EmulatorLauncherConfig(
+            grpc_port=1234, tmp_dir=self.create_tempdir().full_path
+        ),
+        adb_controller=config_classes.AdbControllerConfig(
+            adb_path='/my/adb',
+            adb_server_port=5037,
+        ),
+    )
+    simulator = emulator_simulator.EmulatorSimulator(config)
     self.assertNotEmpty(simulator.adb_device_name())
 
   @mock.patch.object(os.path, 'exists', autospec=True, return_value=True)
   @mock.patch.object(builtins, 'open', autospec=True)
   def test_logfile_path(self, mock_open, unused_mock_exists):
-    tmp_dir = absltest.get_default_test_tmpdir()
-    simulator = emulator_simulator.EmulatorSimulator(
-        tmp_dir=tmp_dir,
+    config = config_classes.EmulatorConfig(
         logfile_path='fake/logfile/path',
-        emulator_launcher_args={'grpc_port': 1234},
-        adb_controller_args={
-            'adb_path': '/my/adb',
-            'adb_server_port': 5037,
-        })
+        emulator_launcher=config_classes.EmulatorLauncherConfig(
+            grpc_port=1234, tmp_dir=self.create_tempdir().full_path
+        ),
+        adb_controller=config_classes.AdbControllerConfig(
+            adb_path='/my/adb',
+            adb_server_port=5037,
+        ),
+    )
+    simulator = emulator_simulator.EmulatorSimulator(config)
     mock_open.return_value.__enter__.return_value.read.return_value = (
         'fake_logs'.encode('utf-8'))
     logs = simulator.get_logs()
@@ -104,61 +109,76 @@ class EmulatorSimulatorTest(absltest.TestCase):
 
   @mock.patch.object(portpicker, 'is_port_free', return_value=True)
   def test_grpc_port(self, unused_mock_portpicker):
-    simulator = emulator_simulator.EmulatorSimulator(
-        tmp_dir=absltest.get_default_test_tmpdir(),
-        emulator_launcher_args={},
-        adb_controller_args={
-            'adb_path': '/my/adb',
-            'adb_server_port': 5037,
-            'prompt_regex': 'awesome>',
-        })
-    self.assertEqual(simulator._grpc_port, 8554)
+
+    launcher_config = config_classes.EmulatorLauncherConfig(
+        tmp_dir=self.create_tempdir().full_path
+    )
+    config = config_classes.EmulatorConfig(
+        emulator_launcher=launcher_config,
+        adb_controller=config_classes.AdbControllerConfig(
+            adb_path='/my/adb',
+            adb_server_port=5037,
+        ),
+    )
+    simulator = emulator_simulator.EmulatorSimulator(config)
+    self.assertEqual(launcher_config.grpc_port, 8554)
 
   @mock.patch.object(portpicker, 'is_port_free', return_value=False)
   def test_grpc_port_unavailable(self, unused_mock_portpicker):
-    simulator = emulator_simulator.EmulatorSimulator(
-        tmp_dir=absltest.get_default_test_tmpdir(),
-        emulator_launcher_args={},
-        adb_controller_args={
-            'adb_path': '/my/adb',
-            'adb_server_port': 5037,
-            'prompt_regex': 'awesome>',
-        })
-    self.assertNotEqual(simulator._grpc_port, 8554)
-
-  def test_launch(self):
-
-    # Make sure that adb_controller is started before Emulator is launched.
+
+    launcher_config = config_classes.EmulatorLauncherConfig(
+        tmp_dir=self.create_tempdir().full_path
+    )
+    config = config_classes.EmulatorConfig(
+        emulator_launcher=launcher_config,
+        adb_controller=config_classes.AdbControllerConfig(
+            adb_path='/my/adb',
+            adb_server_port=5037,
+        ),
+    )
+    simulator = emulator_simulator.EmulatorSimulator(config)
+    self.assertNotEqual(launcher_config.grpc_port, 8554)
+
+  def test_launch_operation_order(self):
+    """Makes sure that adb_controller is started before Emulator is launched."""
+
+    # Arrange.
     call_order = []
-    self._adb_controller.init_server.side_effect = (
-        lambda *a, **kw: call_order.append('init_server'))
+    self._adb_controller.init_server.side_effect = lambda: call_order.append(
+        'init_server'
+    )
     self._launcher.launch_emulator_process.side_effect = (
-        lambda *a, **kw: call_order.append('launch_emulator_process'))
-
-    tmp_dir = absltest.get_default_test_tmpdir()
-    simulator = emulator_simulator.EmulatorSimulator(
-        tmp_dir=tmp_dir,
-        emulator_launcher_args={'grpc_port': 1234},
-        adb_controller_args={
-            'adb_path': '/my/adb',
-            'adb_server_port': 5037,
-            'prompt_regex': 'awesome>',
-        })
+        lambda: call_order.append('launch_emulator_process')
+    )
+    config = config_classes.EmulatorConfig(
+        emulator_launcher=config_classes.EmulatorLauncherConfig(
+            grpc_port=1234, tmp_dir=self.create_tempdir().full_path
+        ),
+        adb_controller=config_classes.AdbControllerConfig(
+            adb_path='/my/adb',
+            adb_server_port=5037,
+        ),
+    )
+    simulator = emulator_simulator.EmulatorSimulator(config)
 
-    # The simulator should launch and not crash.
-    simulator.launch()
+    # Act.
+    simulator.launch()  # The simulator should launch and not crash.
 
+    # Assert.
+    # The adb server should be initialized before launching the emulator.
     self.assertEqual(call_order, ['init_server', 'launch_emulator_process'])
 
   def test_close(self):
-    tmp_dir = absltest.get_default_test_tmpdir()
-    simulator = emulator_simulator.EmulatorSimulator(
-        tmp_dir=tmp_dir,
-        emulator_launcher_args={'grpc_port': 1234},
-        adb_controller_args={
-            'adb_path': '/my/adb',
-            'adb_server_port': 5037,
-        })
+    config = config_classes.EmulatorConfig(
+        emulator_launcher=config_classes.EmulatorLauncherConfig(
+            grpc_port=1234, tmp_dir=self.create_tempdir().full_path
+        ),
+        adb_controller=config_classes.AdbControllerConfig(
+            adb_path='/my/adb',
+            adb_server_port=5037,
+        ),
+    )
+    simulator = emulator_simulator.EmulatorSimulator(config)
 
     # The simulator should launch and not crash.
     simulator.launch()
@@ -169,31 +189,35 @@ class EmulatorSimulatorTest(absltest.TestCase):
     simulator.close()
 
   def test_value_error_if_launch_attempt_params_incorrect(self):
-    tmp_dir = absltest.get_default_test_tmpdir()
     self.assertRaises(
         ValueError,
         emulator_simulator.EmulatorSimulator,
-        tmp_dir=tmp_dir,
-        emulator_launcher_args={'grpc_port': 1234},
-        adb_controller_args={
-            'adb_path': '/my/adb',
-            'adb_server_port': 5037,
-        },
-        launch_n_times_without_reboot=2,
-        launch_n_times_without_reinstall=1,
+        config=config_classes.EmulatorConfig(
+            emulator_launcher=config_classes.EmulatorLauncherConfig(
+                grpc_port=1234, tmp_dir=self.create_tempdir().full_path
+            ),
+            adb_controller=config_classes.AdbControllerConfig(
+                adb_path='/my/adb',
+                adb_server_port=5037,
+            ),
+            launch_n_times_without_reboot=2,
+            launch_n_times_without_reinstall=1,
+        ),
     )
 
   def test_launch_attempt_reboot(self):
-    tmp_dir = absltest.get_default_test_tmpdir()
-    simulator = emulator_simulator.EmulatorSimulator(
-        tmp_dir=tmp_dir,
-        emulator_launcher_args={'grpc_port': 1234},
-        adb_controller_args={
-            'adb_path': '/my/adb',
-            'adb_server_port': 5037,
-        },
+    config = config_classes.EmulatorConfig(
+        emulator_launcher=config_classes.EmulatorLauncherConfig(
+            grpc_port=1234, tmp_dir=self.create_tempdir().full_path
+        ),
+        adb_controller=config_classes.AdbControllerConfig(
+            adb_path='/my/adb',
+            adb_server_port=5037,
+        ),
         launch_n_times_without_reboot=1,
-        launch_n_times_without_reinstall=2)
+        launch_n_times_without_reinstall=2,
+    )
+    simulator = emulator_simulator.EmulatorSimulator(config)
 
     # The simulator should launch and not crash.
     simulator.launch()
@@ -208,16 +232,18 @@ class EmulatorSimulatorTest(absltest.TestCase):
     self._launcher.launch_emulator_process.assert_called_once()
 
   def test_launch_attempt_reinstall_after_zero_attempts(self):
-    tmp_dir = absltest.get_default_test_tmpdir()
-    simulator = emulator_simulator.EmulatorSimulator(
-        tmp_dir=tmp_dir,
-        emulator_launcher_args={'grpc_port': 1234},
-        adb_controller_args={
-            'adb_path': '/my/adb',
-            'adb_server_port': 5037,
-        },
+    config = config_classes.EmulatorConfig(
+        emulator_launcher=config_classes.EmulatorLauncherConfig(
+            grpc_port=1234, tmp_dir=self.create_tempdir().full_path
+        ),
+        adb_controller=config_classes.AdbControllerConfig(
+            adb_path='/my/adb',
+            adb_server_port=5037,
+        ),
         launch_n_times_without_reboot=0,
-        launch_n_times_without_reinstall=0)
+        launch_n_times_without_reinstall=0,
+    )
+    simulator = emulator_simulator.EmulatorSimulator(config)
 
     # The simulator should not reboot or reinstall on its very first launch.
     simulator.launch()
@@ -233,16 +259,18 @@ class EmulatorSimulatorTest(absltest.TestCase):
     self._launcher.launch_emulator_process.assert_called_once()
 
   def test_launch_attempt_reinstall(self):
-    tmp_dir = absltest.get_default_test_tmpdir()
-    simulator = emulator_simulator.EmulatorSimulator(
-        tmp_dir=tmp_dir,
-        emulator_launcher_args={'grpc_port': 1234},
-        adb_controller_args={
-            'adb_path': '/my/adb',
-            'adb_server_port': 5037,
-        },
+    config = config_classes.EmulatorConfig(
+        emulator_launcher=config_classes.EmulatorLauncherConfig(
+            grpc_port=1234, tmp_dir=self.create_tempdir().full_path
+        ),
+        adb_controller=config_classes.AdbControllerConfig(
+            adb_path='/my/adb',
+            adb_server_port=5037,
+        ),
         launch_n_times_without_reboot=1,
-        launch_n_times_without_reinstall=2)
+        launch_n_times_without_reinstall=2,
+    )
+    simulator = emulator_simulator.EmulatorSimulator(config)
 
     # The simulator should launch and not crash.
     simulator.launch()
@@ -263,14 +291,16 @@ class EmulatorSimulatorTest(absltest.TestCase):
     self._launcher.launch_emulator_process.assert_called_once()
 
   def test_get_screenshot(self):
-    tmp_dir = absltest.get_default_test_tmpdir()
-    simulator = emulator_simulator.EmulatorSimulator(
-        tmp_dir=tmp_dir,
-        emulator_launcher_args={'grpc_port': 1234},
-        adb_controller_args={
-            'adb_path': '/my/adb',
-            'adb_server_port': 5037,
-        })
+    config = config_classes.EmulatorConfig(
+        emulator_launcher=config_classes.EmulatorLauncherConfig(
+            grpc_port=1234, tmp_dir=self.create_tempdir().full_path
+        ),
+        adb_controller=config_classes.AdbControllerConfig(
+            adb_path='/my/adb',
+            adb_server_port=5037,
+        ),
+    )
+    simulator = emulator_simulator.EmulatorSimulator(config)
 
     # The simulator should launch and not crash.
     simulator.launch()
@@ -287,15 +317,16 @@ class EmulatorSimulatorTest(absltest.TestCase):
     self.assertEqual(screenshot.shape, (1234, 5678, 3))
 
   def test_load_state(self):
-    tmp_dir = absltest.get_default_test_tmpdir()
-    simulator = emulator_simulator.EmulatorSimulator(
-        tmp_dir=tmp_dir,
-        emulator_launcher_args={'grpc_port': 1234},
-        adb_controller_args={
-            'adb_path': '/my/adb',
-            'adb_server_port': 5037,
-        },
+    config = config_classes.EmulatorConfig(
+        emulator_launcher=config_classes.EmulatorLauncherConfig(
+            grpc_port=1234, tmp_dir=self.create_tempdir().full_path
+        ),
+        adb_controller=config_classes.AdbControllerConfig(
+            adb_path='/my/adb',
+            adb_server_port=5037,
+        ),
     )
+    simulator = emulator_simulator.EmulatorSimulator(config)
 
     # The simulator should launch and not crash.
     simulator.launch()
@@ -340,15 +371,16 @@ class EmulatorSimulatorTest(absltest.TestCase):
       self.assertEqual(load_response.error_message, 'error')
 
   def test_save_state(self):
-    tmp_dir = absltest.get_default_test_tmpdir()
-    simulator = emulator_simulator.EmulatorSimulator(
-        tmp_dir=tmp_dir,
-        emulator_launcher_args={'grpc_port': 1234},
-        adb_controller_args={
-            'adb_path': '/my/adb',
-            'adb_server_port': 5037,
-        },
+    config = config_classes.EmulatorConfig(
+        emulator_launcher=config_classes.EmulatorLauncherConfig(
+            grpc_port=1234, tmp_dir=self.create_tempdir().full_path
+        ),
+        adb_controller=config_classes.AdbControllerConfig(
+            adb_path='/my/adb',
+            adb_server_port=5037,
+        ),
     )
+    simulator = emulator_simulator.EmulatorSimulator(config)
 
     # The simulator should launch and not crash.
     simulator.launch()
@@ -381,14 +413,16 @@ class EmulatorSimulatorTest(absltest.TestCase):
       self.assertEqual(save_response.error_message, 'error')
 
   def test_send_touch(self):
-    tmp_dir = absltest.get_default_test_tmpdir()
-    simulator = emulator_simulator.EmulatorSimulator(
-        tmp_dir=tmp_dir,
-        emulator_launcher_args={'grpc_port': 1234},
-        adb_controller_args={
-            'adb_path': '/my/adb',
-            'adb_server_port': 5037,
-        })
+    config = config_classes.EmulatorConfig(
+        emulator_launcher=config_classes.EmulatorLauncherConfig(
+            grpc_port=1234, tmp_dir=self.create_tempdir().full_path
+        ),
+        adb_controller=config_classes.AdbControllerConfig(
+            adb_path='/my/adb',
+            adb_server_port=5037,
+        ),
+    )
+    simulator = emulator_simulator.EmulatorSimulator(config)
 
     # The simulator should launch and not crash.
     simulator.launch()
@@ -436,14 +470,16 @@ class EmulatorSimulatorTest(absltest.TestCase):
     ])
 
   def test_send_key(self):
-    tmp_dir = absltest.get_default_test_tmpdir()
-    simulator = emulator_simulator.EmulatorSimulator(
-        tmp_dir=tmp_dir,
-        emulator_launcher_args={'grpc_port': 1234},
-        adb_controller_args={
-            'adb_path': '/my/adb',
-            'adb_server_port': 5037,
-        })
+    config = config_classes.EmulatorConfig(
+        emulator_launcher=config_classes.EmulatorLauncherConfig(
+            grpc_port=1234, tmp_dir=self.create_tempdir().full_path
+        ),
+        adb_controller=config_classes.AdbControllerConfig(
+            adb_path='/my/adb',
+            adb_server_port=5037,
+        ),
+    )
+    simulator = emulator_simulator.EmulatorSimulator(config)
 
     # The simulator should launch and not crash.
     simulator.launch()

android_env/components/simulators/fake/__init__.py

@@ -1,5 +1,5 @@
 # coding=utf-8
-# Copyright 2023 DeepMind Technologies Limited.
+# Copyright 2024 DeepMind Technologies Limited.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.

android_env/components/simulators/fake/fake_simulator.py

@@ -1,5 +1,5 @@
 # coding=utf-8
-# Copyright 2023 DeepMind Technologies Limited.
+# Copyright 2024 DeepMind Technologies Limited.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -18,10 +18,10 @@
 import random
 import threading
 import time
-from typing import Optional
 
 from absl import logging
 from android_env.components import adb_controller
+from android_env.components import config_classes
 from android_env.components import log_stream
 from android_env.components.simulators import base_simulator
 import numpy as np
@@ -80,7 +80,7 @@ class FakeAdbController(adb_controller.AdbController):
   def execute_command(
       self,
       args: list[str],
-      timeout: Optional[float] = None,
+      timeout: float | None = None,
       device_specific: bool = True,
   ) -> bytes:
     """Returns fake output for adb commands."""
@@ -106,18 +106,10 @@ class FakeAdbController(adb_controller.AdbController):
 class FakeSimulator(base_simulator.BaseSimulator):
   """FakeSimulator class."""
 
-  def __init__(self,
-               screen_dimensions: tuple[int, int] = (480, 320),
-               **kwargs):
-    """FakeSimulator class that can replace EmulatorSimulator in AndroidEnv.
-
-    Args:
-      screen_dimensions: desired screen dimensions in pixels. This determines
-        the shape of the screenshots returned by get_screenshot().
-      **kwargs: other keyword arguments for the base class.
-    """
-    super().__init__(**kwargs)
-    self._screen_dimensions = np.array(screen_dimensions)
+  def __init__(self, config: config_classes.FakeSimulatorConfig):
+    """FakeSimulator class that can replace EmulatorSimulator in AndroidEnv."""
+    super().__init__(config)
+    self._screen_dimensions = np.array(config.screen_dimensions)
     logging.info('Created FakeSimulator.')
 
   def get_logs(self) -> str:
@@ -127,7 +119,7 @@ class FakeSimulator(base_simulator.BaseSimulator):
     return 'fake_simulator'
 
   def create_adb_controller(self):
-    return FakeAdbController()
+    return FakeAdbController(config_classes.AdbControllerConfig())
 
   def create_log_stream(self) -> log_stream.LogStream:
     return FakeLogStream()
@@ -141,6 +133,6 @@ class FakeSimulator(base_simulator.BaseSimulator):
   def send_key(self, keycode: np.int32, event_type: str) -> None:
     del keycode, event_type
 
-  def get_screenshot(self) -> np.ndarray:
+  def _get_screenshot_impl(self) -> np.ndarray:
     return np.random.randint(
         low=0, high=255, size=(*self._screen_dimensions, 3), dtype=np.uint8)

android_env/components/simulators/fake/fake_simulator_test.py

@@ -1,5 +1,5 @@
 # coding=utf-8
-# Copyright 2023 DeepMind Technologies Limited.
+# Copyright 2024 DeepMind Technologies Limited.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -17,6 +17,7 @@
 
 import re
 from absl.testing import absltest
+from android_env.components import config_classes
 from android_env.components.simulators.fake import fake_simulator
 import numpy as np
 
@@ -24,18 +25,24 @@ import numpy as np
 class FakeSimulatorTest(absltest.TestCase):
 
   def test_device_name(self):
-    simulator = fake_simulator.FakeSimulator(screen_dimensions=(320, 480))
+    simulator = fake_simulator.FakeSimulator(
+        config_classes.FakeSimulatorConfig(screen_dimensions=(320, 480))
+    )
     self.assertEqual(simulator.adb_device_name(), 'fake_simulator')
 
   def test_launch_close(self):
     # The simulator should launch and not crash.
-    simulator = fake_simulator.FakeSimulator(screen_dimensions=(320, 480))
+    simulator = fake_simulator.FakeSimulator(
+        config_classes.FakeSimulatorConfig(screen_dimensions=(320, 480))
+    )
     simulator.launch()
     # Closing the simulator should also not crash.
     simulator.close()
 
   def test_get_screenshot(self):
-    simulator = fake_simulator.FakeSimulator(screen_dimensions=(320, 480))
+    simulator = fake_simulator.FakeSimulator(
+        config_classes.FakeSimulatorConfig(screen_dimensions=(320, 480))
+    )
     simulator.launch()
 
     screenshot = simulator.get_screenshot()
@@ -43,7 +50,9 @@ class FakeSimulatorTest(absltest.TestCase):
     np.testing.assert_equal(screenshot.dtype, np.uint8)
 
   def test_log_stream(self):
-    simulator = fake_simulator.FakeSimulator(screen_dimensions=(320, 480))
+    simulator = fake_simulator.FakeSimulator(
+        config_classes.FakeSimulatorConfig(screen_dimensions=(320, 480))
+    )
     simulator.launch()
     log_stream = simulator.create_log_stream()
     # Start yielding lines from LogStream.
@@ -61,7 +70,9 @@ class FakeSimulatorTest(absltest.TestCase):
         break
 
   def test_adb_output(self):
-    simulator = fake_simulator.FakeSimulator(screen_dimensions=(320, 480))
+    simulator = fake_simulator.FakeSimulator(
+        config_classes.FakeSimulatorConfig(screen_dimensions=(320, 480))
+    )
     simulator.launch()
     adb_controller = simulator.create_adb_controller()
     line = adb_controller.execute_command(['shell', 'dumpsys', 'input'])
@@ -79,7 +90,9 @@ class FakeSimulatorTest(absltest.TestCase):
                      'topActivity=ComponentInfo{fake_activity}')
 
   def test_send_touch(self):
-    simulator = fake_simulator.FakeSimulator(screen_dimensions=(320, 480))
+    simulator = fake_simulator.FakeSimulator(
+        config_classes.FakeSimulatorConfig(screen_dimensions=(320, 480))
+    )
     simulator.launch()
     simulator.send_touch([(0, 1, True, 0)])
     simulator.send_touch([(0, 1, False, 0)])
@@ -87,7 +100,9 @@ class FakeSimulatorTest(absltest.TestCase):
     # without crashing anything.
 
   def test_send_key(self):
-    simulator = fake_simulator.FakeSimulator(screen_dimensions=(320, 480))
+    simulator = fake_simulator.FakeSimulator(
+        config_classes.FakeSimulatorConfig(screen_dimensions=(320, 480))
+    )
     simulator.launch()
     simulator.send_key(np.int32(123), 'keydown')
     simulator.send_key(np.int32(123), 'keyup')

android_env/components/specs.py

@@ -1,5 +1,5 @@
 # coding=utf-8
-# Copyright 2023 DeepMind Technologies Limited.
+# Copyright 2024 DeepMind Technologies Limited.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.

android_env/components/specs_test.py

@@ -1,5 +1,5 @@
 # coding=utf-8
-# Copyright 2023 DeepMind Technologies Limited.
+# Copyright 2024 DeepMind Technologies Limited.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.