minitap-mobile-use 2.0.0__py3-none-any.whl → 2.1.0__py3-none-any.whl

minitap/mobile_use/graph/state.py

@@ -1,9 +1,10 @@
 from langchain_core.messages import AIMessage, AnyMessage
 from langgraph.graph import add_messages
 from langgraph.prebuilt.chat_agent_executor import AgentStatePydantic
-from typing_extensions import Annotated, Optional
+from typing import Annotated
 
 from minitap.mobile_use.agents.planner.types import Subgoal
+from minitap.mobile_use.config import AgentNode
 from minitap.mobile_use.utils.logger import get_logger
 from minitap.mobile_use.utils.recorder import record_interaction
 from minitap.mobile_use.context import MobileUseContext
@@ -23,51 +24,70 @@ class State(AgentStatePydantic):
     subgoal_plan: Annotated[list[Subgoal], "The current plan, made of subgoals"]
 
     # contextor related keys
-    latest_screenshot_base64: Annotated[Optional[str], "Latest screenshot of the device", take_last]
+    latest_screenshot_base64: Annotated[str | None, "Latest screenshot of the device", take_last]
     latest_ui_hierarchy: Annotated[
-        Optional[list[dict]], "Latest UI hierarchy of the device", take_last
+        list[dict] | None, "Latest UI hierarchy of the device", take_last
     ]
-    focused_app_info: Annotated[Optional[str], "Focused app info", take_last]
-    device_date: Annotated[Optional[str], "Date of the device", take_last]
+    focused_app_info: Annotated[str | None, "Focused app info", take_last]
+    device_date: Annotated[str | None, "Date of the device", take_last]
 
     # cortex related keys
     structured_decisions: Annotated[
-        Optional[str],
+        str | None,
         "Structured decisions made by the cortex, for the executor to follow",
         take_last,
     ]
+    complete_subgoals_by_ids: Annotated[
+        list[str],
+        "List of subgoal IDs to complete",
+        take_last,
+    ]
 
     # executor related keys
-    executor_retrigger: Annotated[Optional[bool], "Whether the executor must be retriggered"]
-    executor_failed: Annotated[bool, "Whether a tool call made by the executor failed"]
     executor_messages: Annotated[list[AnyMessage], "Sequential Executor messages", add_messages]
-    cortex_last_thought: Annotated[Optional[str], "Last thought of the cortex for the executor"]
+    cortex_last_thought: Annotated[str | None, "Last thought of the cortex for the executor"]
 
     # common keys
     agents_thoughts: Annotated[
         list[str],
         "All thoughts and reasons that led to actions (why a tool was called, expected outcomes..)",
+        take_last,
     ]
 
-    def sanitize_update(self, ctx: MobileUseContext, update: dict):
+    def sanitize_update(
+        self,
+        ctx: MobileUseContext,
+        update: dict,
+        agent: AgentNode | None = None,
+    ):
         """
         Sanitizes the state update to ensure it is valid and apply side effect logic where required.
+        The agent is required if the update contains the "agents_thoughts" key.
         """
-        updated_agents_thoughts: Optional[str | list[str]] = update.get("agents_thoughts", None)
+        updated_agents_thoughts: str | list[str] | None = update.get("agents_thoughts", None)
         if updated_agents_thoughts is not None:
             if isinstance(updated_agents_thoughts, str):
                 updated_agents_thoughts = [updated_agents_thoughts]
             elif not isinstance(updated_agents_thoughts, list):
                 raise ValueError("agents_thoughts must be a str or list[str]")
+            if agent is None:
+                raise ValueError("Agent is required when updating the 'agents_thoughts' key")
             update["agents_thoughts"] = _add_agent_thoughts(
                 ctx=ctx,
                 old=self.agents_thoughts,
                 new=updated_agents_thoughts,
+                agent=agent,
             )
         return update
 
 
-def _add_agent_thoughts(ctx: MobileUseContext, old: list[str], new: list[str]) -> list[str]:
+def _add_agent_thoughts(
+    ctx: MobileUseContext,
+    old: list[str],
+    new: list[str],
+    agent: AgentNode,
+) -> list[str]:
+    named_thoughts = [f"[{agent}] {thought}" for thought in new]
     if ctx.execution_setup:
-        record_interaction(ctx, response=AIMessage(content=str(new)))
-    return old + new
+        record_interaction(ctx, response=AIMessage(content=str(named_thoughts)))
+    return old + named_thoughts

minitap/mobile_use/main.py

@@ -1,11 +1,11 @@
 import asyncio
 import os
-from adbutils import AdbClient
-from typing import Optional
 
 import typer
+from adbutils import AdbClient
+from langchain.callbacks.base import Callbacks
 from rich.console import Console
-from typing_extensions import Annotated
+from typing import Annotated
 
 from minitap.mobile_use.config import (
     initialize_llm_config,
@@ -23,9 +23,10 @@ logger = get_logger(__name__)
 
 async def run_automation(
     goal: str,
-    test_name: Optional[str] = None,
+    test_name: str | None = None,
     traces_output_path_str: str = "traces",
-    output_description: Optional[str] = None,
+    output_description: str | None = None,
+    graph_config_callbacks: Callbacks = [],
 ):
     llm_config = initialize_llm_config()
     agent_profile = AgentProfile(name="default", llm_config=llm_config)
@@ -37,11 +38,13 @@ async def run_automation(
         config.with_hw_bridge_base_url(url=settings.DEVICE_HARDWARE_BRIDGE_BASE_URL)
     if settings.DEVICE_SCREEN_API_BASE_URL:
         config.with_screen_api_base_url(url=settings.DEVICE_SCREEN_API_BASE_URL)
+    if graph_config_callbacks:
+        config.with_graph_config_callbacks(graph_config_callbacks)
 
     agent = Agent(config=config.build())
     agent.init(
         retry_count=int(os.getenv("MOBILE_USE_HEALTH_RETRIES", 5)),
-        retry_wait_seconds=int(os.getenv("MOBILE_USE_HEALTH_DELAY", 5)),
+        retry_wait_seconds=int(os.getenv("MOBILE_USE_HEALTH_DELAY", 2)),
     )
 
     task = agent.new_task(goal)
@@ -66,7 +69,7 @@ async def run_automation(
 def main(
     goal: Annotated[str, typer.Argument(help="The main goal for the agent to achieve.")],
     test_name: Annotated[
-        Optional[str],
+        str | None,
         typer.Option(
             "--test-name",
             "-n",
@@ -82,7 +85,7 @@ def main(
         ),
     ] = "traces",
     output_description: Annotated[
-        Optional[str],
+        str | None,
         typer.Option(
             "--output-description",
             "-o",

minitap/mobile_use/sdk/agent.py

@@ -1,68 +1,67 @@
 import asyncio
-from datetime import datetime
-from pathlib import Path
 import sys
 import tempfile
 import time
-from types import NoneType
-from typing import Optional, TypeVar, overload
 import uuid
+from datetime import datetime
+from pathlib import Path
+from types import NoneType
+from typing import TypeVar, overload
+
 from adbutils import AdbClient
 from langchain_core.messages import AIMessage
 from pydantic import BaseModel
-from minitap.mobile_use.agents.outputter.outputter import outputter
 
+from minitap.mobile_use.agents.outputter.outputter import outputter
+from minitap.mobile_use.clients.device_hardware_client import DeviceHardwareClient
+from minitap.mobile_use.clients.screen_api_client import ScreenApiClient
 from minitap.mobile_use.config import OutputConfig, record_events
-from minitap.mobile_use.graph.graph import get_graph
-from minitap.mobile_use.graph.state import State
-from minitap.mobile_use.sdk.builders.agent_config_builder import get_default_agent_config
-from minitap.mobile_use.sdk.builders.task_request_builder import TaskRequestBuilder
-from minitap.mobile_use.sdk.constants import (
-    DEFAULT_HW_BRIDGE_BASE_URL,
-    DEFAULT_SCREEN_API_BASE_URL,
-)
-from minitap.mobile_use.sdk.types.agent import AgentConfig
 from minitap.mobile_use.context import (
     DeviceContext,
     DevicePlatform,
     ExecutionSetup,
     MobileUseContext,
 )
-from minitap.mobile_use.clients.device_hardware_client import DeviceHardwareClient
-from minitap.mobile_use.clients.screen_api_client import ScreenApiClient
 from minitap.mobile_use.controllers.mobile_command_controller import (
     ScreenDataResponse,
     get_screen_data,
 )
 from minitap.mobile_use.controllers.platform_specific_commands_controller import get_first_device
-
-from minitap.mobile_use.servers.stop_servers import stop_servers
-from minitap.mobile_use.servers.device_hardware_bridge import BridgeStatus
-from minitap.mobile_use.servers.start_servers import (
-    start_device_hardware_bridge,
-    start_device_screen_api,
+from minitap.mobile_use.graph.graph import get_graph
+from minitap.mobile_use.graph.state import State
+from minitap.mobile_use.sdk.builders.agent_config_builder import get_default_agent_config
+from minitap.mobile_use.sdk.builders.task_request_builder import TaskRequestBuilder
+from minitap.mobile_use.sdk.constants import (
+    DEFAULT_HW_BRIDGE_BASE_URL,
+    DEFAULT_SCREEN_API_BASE_URL,
 )
-from minitap.mobile_use.utils.logger import get_logger
+from minitap.mobile_use.sdk.types.agent import AgentConfig
 from minitap.mobile_use.sdk.types.exceptions import (
+    AgentNotInitializedError,
     AgentProfileNotFoundError,
     AgentTaskRequestError,
     DeviceNotFoundError,
     ServerStartupError,
-    AgentNotInitializedError,
 )
 from minitap.mobile_use.sdk.types.task import AgentProfile, Task, TaskRequest, TaskStatus
+from minitap.mobile_use.servers.device_hardware_bridge import BridgeStatus
+from minitap.mobile_use.servers.start_servers import (
+    start_device_hardware_bridge,
+    start_device_screen_api,
+)
+from minitap.mobile_use.servers.stop_servers import stop_servers
+from minitap.mobile_use.utils.logger import get_logger
 from minitap.mobile_use.utils.media import (
     create_gif_from_trace_folder,
     create_steps_json_from_trace_folder,
     remove_images_from_trace_folder,
     remove_steps_json_from_trace_folder,
 )
-from minitap.mobile_use.utils.recorder import log_agent_thoughts
-
+from minitap.mobile_use.utils.recorder import log_agent_thought
 
 logger = get_logger(__name__)
 
-TOutput = TypeVar("TOutput", bound=Optional[BaseModel])
+TOutput = TypeVar("TOutput", bound=BaseModel | None)
 
 
 class Agent:
@@ -75,9 +74,9 @@ class Agent:
     _device_context: DeviceContext
     _screen_api_client: ScreenApiClient
     _hw_bridge_client: DeviceHardwareClient
-    _adb_client: Optional[AdbClient]
+    _adb_client: AdbClient | None
 
-    def __init__(self, config: Optional[AgentConfig] = None):
+    def __init__(self, config: AgentConfig | None = None):
         self._config = config or get_default_agent_config()
         self._tasks = []
         self._tmp_traces_dir = Path(tempfile.gettempdir()) / "mobile-use-traces"
@@ -127,7 +126,10 @@ class Agent:
                     f"Server start failed, attempting restart "
                     f"{restart_attempt}/{server_restart_attempts}"
                 )
-                time.sleep(3)
+                stop_servers(
+                    should_stop_screen_api=self._is_default_screen_api,
+                    should_stop_hw_bridge=self._is_default_hw_bridge,
+                )
             else:
                 error_msg = "Mobile-use servers failed to start after all restart attempts."
                 logger.error(error_msg)
@@ -151,9 +153,9 @@ class Agent:
         *,
         goal: str,
         output: type[TOutput],
-        profile: Optional[str | AgentProfile] = None,
-        name: Optional[str] = None,
-    ) -> Optional[TOutput]: ...
+        profile: str | AgentProfile | None = None,
+        name: str | None = None,
+    ) -> TOutput | None: ...
 
     @overload
     async def run_task(
@@ -161,9 +163,9 @@ class Agent:
         *,
         goal: str,
         output: str,
-        profile: Optional[str | AgentProfile] = None,
-        name: Optional[str] = None,
-    ) -> Optional[str | dict]: ...
+        profile: str | AgentProfile | None = None,
+        name: str | None = None,
+    ) -> str | dict | None: ...
 
     @overload
     async def run_task(
@@ -171,25 +173,25 @@ class Agent:
         *,
         goal: str,
         output=None,
-        profile: Optional[str | AgentProfile] = None,
-        name: Optional[str] = None,
-    ) -> Optional[str]: ...
+        profile: str | AgentProfile | None = None,
+        name: str | None = None,
+    ) -> str | None: ...
 
     @overload
-    async def run_task(self, *, request: TaskRequest[None]) -> Optional[str | dict]: ...
+    async def run_task(self, *, request: TaskRequest[None]) -> str | dict | None: ...
 
     @overload
-    async def run_task(self, *, request: TaskRequest[TOutput]) -> Optional[TOutput]: ...
+    async def run_task(self, *, request: TaskRequest[TOutput]) -> TOutput | None: ...
 
     async def run_task(
         self,
         *,
-        goal: Optional[str] = None,
-        output: Optional[type[TOutput] | str] = None,
-        profile: Optional[str | AgentProfile] = None,
-        name: Optional[str] = None,
-        request: Optional[TaskRequest[TOutput]] = None,
-    ) -> Optional[str | dict | TOutput]:
+        goal: str | None = None,
+        output: type[TOutput] | str | None = None,
+        profile: str | AgentProfile | None = None,
+        name: str | None = None,
+        request: TaskRequest[TOutput] | None = None,
+    ) -> str | dict | TOutput | None:
         if request is not None:
             return await self._run_task(request)
         if goal is None:
@@ -206,7 +208,7 @@ class Agent:
             task_request.with_name(name=name)
         return await self._run_task(task_request.build())
 
-    async def _run_task(self, request: TaskRequest[TOutput]) -> Optional[str | dict | TOutput]:
+    async def _run_task(self, request: TaskRequest[TOutput]) -> str | dict | TOutput | None:
         if not self._initialized:
             raise AgentNotInitializedError()
 
@@ -261,17 +263,31 @@ class Agent:
                 input=graph_input,
                 config={
                     "recursion_limit": task.request.max_steps,
+                    "callbacks": self._config.graph_config_callbacks,
                 },
-                stream_mode=["messages", "custom", "values"],
+                stream_mode=["messages", "custom", "updates", "values"],
             ):
-                stream_mode, content = chunk
+                stream_mode, payload = chunk
                 if stream_mode == "values":
-                    last_state_snapshot = content  # type: ignore
+                    last_state_snapshot = payload  # type: ignore
                     last_state = State(**last_state_snapshot)  # type: ignore
-                    log_agent_thoughts(
-                        agents_thoughts=last_state.agents_thoughts,
-                        output_path=task.request.thoughts_output_path,
-                    )
+                    if task.request.thoughts_output_path:
+                        record_events(
+                            output_path=task.request.thoughts_output_path,
+                            events=last_state.agents_thoughts,
+                        )
+
+                if stream_mode == "updates":
+                    for key, value in payload.items():  # type: ignore
+                        if value and "agents_thoughts" in value:
+                            new_thoughts = value["agents_thoughts"]
+                            last_item = new_thoughts[-1] if new_thoughts else None
+                            if last_item:
+                                log_agent_thought(
+                                    prefix=key,
+                                    agent_thought=last_item,
+                                )
+
             if not last_state:
                 err = f"[{task_name}] No result received from graph"
                 logger.warning(err)
@@ -302,12 +318,12 @@ class Agent:
             self._finalize_tracing(task=task, context=context)
         return output
 
-    def clean(self):
-        if not self._initialized:
+    def clean(self, force: bool = False):
+        if not self._initialized and not force:
             return
         screen_api_ok, hw_bridge_ok = stop_servers(
-            device_screen_api=not self._is_default_screen_api,
-            device_hardware_bridge=not self._is_default_hw_bridge,
+            should_stop_screen_api=self._is_default_screen_api,
+            should_stop_hw_bridge=self._is_default_hw_bridge,
         )
         if not screen_api_ok:
             logger.warning("Failed to stop Device Screen API.")
@@ -366,9 +382,9 @@ class Agent:
         task_name: str,
         ctx: MobileUseContext,
         request: TaskRequest[TOutput],
-        output_config: Optional[OutputConfig],
+        output_config: OutputConfig | None,
         state: State,
-    ) -> Optional[str | dict | TOutput]:
+    ) -> str | dict | TOutput | None:
         if output_config and output_config.needs_structured_format():
             logger.info(f"[{task_name}] Generating structured output...")
             try:
@@ -402,10 +418,9 @@ class Agent:
             focused_app_info=None,
             device_date=None,
             structured_decisions=None,
+            complete_subgoals_by_ids=[],
             agents_thoughts=[],
             remaining_steps=task.request.max_steps,
-            executor_retrigger=False,
-            executor_failed=False,
             executor_messages=[],
             cortex_last_thought=None,
         )

minitap/mobile_use/sdk/builders/agent_config_builder.py

@@ -2,19 +2,19 @@
 Builder for AgentConfig objects using a fluent interface.
 """
 
-from typing import Dict, Optional, List
 import copy
 
+from langchain_core.callbacks.base import Callbacks
+
 from minitap.mobile_use.config import get_default_llm_config
+from minitap.mobile_use.context import DevicePlatform
 from minitap.mobile_use.sdk.constants import (
     DEFAULT_HW_BRIDGE_BASE_URL,
     DEFAULT_PROFILE_NAME,
     DEFAULT_SCREEN_API_BASE_URL,
 )
-from minitap.mobile_use.sdk.types.agent import ApiBaseUrl, AgentConfig, ServerConfig
-from minitap.mobile_use.sdk.types.agent import AgentProfile
+from minitap.mobile_use.sdk.types.agent import AgentConfig, AgentProfile, ApiBaseUrl, ServerConfig
 from minitap.mobile_use.sdk.types.task import TaskRequestCommon
-from minitap.mobile_use.context import DevicePlatform
 
 
 class AgentConfigBuilder:
@@ -38,12 +38,13 @@ class AgentConfigBuilder:
 
     def __init__(self):
         """Initialize an empty AgentConfigBuilder."""
-        self._agent_profiles: Dict[str, AgentProfile] = {}
-        self._task_request_defaults: Optional[TaskRequestCommon] = None
-        self._default_profile: Optional[str | AgentProfile] = None
-        self._device_id: Optional[str] = None
-        self._device_platform: Optional[DevicePlatform] = None
+        self._agent_profiles: dict[str, AgentProfile] = {}
+        self._task_request_defaults: TaskRequestCommon | None = None
+        self._default_profile: str | AgentProfile | None = None
+        self._device_id: str | None = None
+        self._device_platform: DevicePlatform | None = None
         self._servers: ServerConfig = get_default_servers()
+        self._graph_config_callbacks: Callbacks = None
 
     def add_profile(self, profile: AgentProfile) -> "AgentConfigBuilder":
         """
@@ -56,7 +57,7 @@ class AgentConfigBuilder:
         profile.llm_config.validate_providers()
         return self
 
-    def add_profiles(self, profiles: List[AgentProfile]) -> "AgentConfigBuilder":
+    def add_profiles(self, profiles: list[AgentProfile]) -> "AgentConfigBuilder":
         """
         Add multiple agent profiles to the mobile-use agent.
 
@@ -128,7 +129,7 @@ class AgentConfigBuilder:
         self._servers.screen_api_base_url = url
         return self
 
-    def with_adb_server(self, host: str, port: Optional[int] = None) -> "AgentConfigBuilder":
+    def with_adb_server(self, host: str, port: int | None = None) -> "AgentConfigBuilder":
         """
         Set the ADB server host and port.
 
@@ -151,6 +152,16 @@ class AgentConfigBuilder:
         self._servers = copy.deepcopy(servers)
         return self
 
+    def with_graph_config_callbacks(self, callbacks: Callbacks) -> "AgentConfigBuilder":
+        """
+        Set the graph config callbacks.
+
+        Args:
+            callbacks: The graph config callbacks to use
+        """
+        self._graph_config_callbacks = callbacks
+        return self
+
     def build(self) -> AgentConfig:
         """
         Build the mobile-use AgentConfig object.
@@ -197,6 +208,7 @@ class AgentConfigBuilder:
             device_id=self._device_id,
             device_platform=self._device_platform,
             servers=self._servers,
+            graph_config_callbacks=self._graph_config_callbacks,
         )
 
 

minitap/mobile_use/sdk/builders/task_request_builder.py

@@ -3,7 +3,7 @@ Builder for TaskRequest objects using a fluent interface.
 """
 
 from pathlib import Path
-from typing import Generic, Optional, Self, TypeVar, cast
+from typing import Self, TypeVar, cast
 
 from pydantic import BaseModel
 
@@ -12,7 +12,7 @@ from minitap.mobile_use.sdk.types.agent import AgentProfile
 from minitap.mobile_use.sdk.types.task import TaskRequest, TaskRequestCommon
 
 
-TIn = TypeVar("TIn", bound=Optional[BaseModel])
+TIn = TypeVar("TIn", bound=BaseModel | None)
 TOut = TypeVar("TOut", bound=BaseModel)
 
 
@@ -25,8 +25,8 @@ class TaskRequestCommonBuilder(BaseModel):
         self._max_steps = RECURSION_LIMIT
         self._record_trace = False
         self._trace_path = Path("mobile-use-traces")
-        self._llm_output_path: Optional[Path] = None
-        self._thoughts_output_path: Optional[Path] = None
+        self._llm_output_path: Path | None = None
+        self._thoughts_output_path: Path | None = None
 
     def with_max_steps(self, max_steps: int) -> Self:
         """
@@ -38,7 +38,7 @@ class TaskRequestCommonBuilder(BaseModel):
         self._max_steps = max_steps
         return self
 
-    def with_trace_recording(self, enabled: bool = True, path: Optional[str] = None) -> Self:
+    def with_trace_recording(self, enabled: bool = True, path: str | None = None) -> Self:
         """
         Configure trace recording for the task.
 
@@ -92,7 +92,7 @@ class TaskRequestCommonBuilder(BaseModel):
         )
 
 
-class TaskRequestBuilder(TaskRequestCommonBuilder, Generic[TIn]):
+class TaskRequestBuilder[TIn](TaskRequestCommonBuilder):
     """
     Builder class providing a fluent interface for creating TaskRequest objects.
 
@@ -114,10 +114,10 @@ class TaskRequestBuilder(TaskRequestCommonBuilder, Generic[TIn]):
         """Initialize an empty TaskRequestBuilder."""
         super().__init__()
         self._goal = goal
-        self._profile: Optional[str | AgentProfile] = None
-        self._name: Optional[str] = None
+        self._profile: str | AgentProfile | None = None
+        self._name: str | None = None
         self._output_description = None
-        self._output_format: Optional[type[TIn]] = None
+        self._output_format: type[TIn] | None = None
 
     @classmethod
     def from_common(cls, goal: str, common: TaskRequestCommon):

minitap/mobile_use/sdk/examples/smart_notification_assistant.py

@@ -20,7 +20,6 @@ Run:
 import asyncio
 from datetime import datetime
 from enum import Enum
-from typing import List
 
 from pydantic import BaseModel, Field
 from minitap.mobile_use.config import LLM, LLMConfig, LLMConfigUtils, LLMWithFallback
@@ -52,7 +51,7 @@ class NotificationSummary(BaseModel):
 
     total_count: int = Field(..., description="Total number of notifications found")
     high_priority_count: int = Field(0, description="Count of high priority notifications")
-    notifications: List[Notification] = Field(
+    notifications: list[Notification] = Field(
         default_factory=list, description="List of individual notifications"
     )
 

minitap/mobile_use/sdk/types/agent.py

@@ -1,5 +1,7 @@
-from typing import Dict, Literal, Optional
+from typing import Literal
 from urllib.parse import urlparse
+
+from langchain_core.callbacks.base import Callbacks
 from pydantic import BaseModel
 
 from minitap.mobile_use.context import DevicePlatform
@@ -13,7 +15,7 @@ class ApiBaseUrl(BaseModel):
 
     scheme: Literal["http", "https"]
     host: str
-    port: Optional[int] = None
+    port: int | None = None
 
     def __eq__(self, other):
         if not isinstance(other, ApiBaseUrl):
@@ -65,9 +67,12 @@ class AgentConfig(BaseModel):
         servers: Custom server configurations.
     """
 
-    agent_profiles: Dict[str, AgentProfile]
+    agent_profiles: dict[str, AgentProfile]
     task_request_defaults: TaskRequestCommon
     default_profile: AgentProfile
-    device_id: Optional[str] = None
-    device_platform: Optional[DevicePlatform] = None
+    device_id: str | None = None
+    device_platform: DevicePlatform | None = None
     servers: ServerConfig
+    graph_config_callbacks: Callbacks = None
+
+    model_config = {"arbitrary_types_allowed": True}