uipath 2.1.40__tar.gz → 2.1.42__tar.gz

{uipath-2.1.40 → uipath-2.1.42}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath
-Version: 2.1.40
+Version: 2.1.42
 Summary: Python SDK and CLI for UiPath Platform, enabling programmatic interaction with automation services, process management, and deployment tools.
 Project-URL: Homepage, https://uipath.com
 Project-URL: Repository, https://github.com/UiPath/uipath-python

{uipath-2.1.40 → uipath-2.1.42}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "uipath"
-version = "2.1.40"
+version = "2.1.42"
 description = "Python SDK and CLI for UiPath Platform, enabling programmatic interaction with automation services, process management, and deployment tools."
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.10"

{uipath-2.1.40 → uipath-2.1.42}/src/uipath/_cli/_auth/_auth_server.py

@@ -7,7 +7,7 @@ import threading
 import time
 from typing import Optional
 
-from ._oidc_utils import get_auth_config
+from ._oidc_utils import OidcUtils
 
 # Server port
 PORT = 6234
@@ -74,7 +74,7 @@ def make_request_handler_class(state, code_verifier, token_callback, domain):
                     content = f.read()
 
                 # Get the redirect URI from auth config
-                auth_config = get_auth_config()
+                auth_config = OidcUtils.get_auth_config()
                 redirect_uri = auth_config["redirect_uri"]
 
                 content = content.replace("__PY_REPLACE_EXPECTED_STATE__", state)

uipath-2.1.42/src/uipath/_cli/_auth/_auth_service.py

@@ -0,0 +1,151 @@
+import asyncio
+import json
+import os
+import webbrowser
+from socket import AF_INET, SOCK_STREAM, error, socket
+from typing import Optional
+from urllib.parse import urlparse
+
+from uipath._cli._auth._auth_server import HTTPServer
+from uipath._cli._auth._client_credentials import ClientCredentialsService
+from uipath._cli._auth._oidc_utils import OidcUtils
+from uipath._cli._auth._portal_service import PortalService, select_tenant
+from uipath._cli._auth._url_utils import set_force_flag
+from uipath._cli._auth._utils import update_auth_file, update_env_file
+from uipath._cli._utils._console import ConsoleLogger
+
+
+class AuthService:
+    def __init__(
+        self,
+        environment: str,
+        *,
+        force: bool,
+        client_id: Optional[str],
+        client_secret: Optional[str],
+        base_url: Optional[str],
+        scope: Optional[str],
+    ):
+        self._force = force
+        self._console = ConsoleLogger()
+        self._domain = self._get_domain(environment)
+        self._client_id = client_id
+        self._client_secret = client_secret
+        self._base_url = base_url
+        self._scope = scope
+        set_force_flag(self._force)
+
+    def _get_domain(self, environment: str) -> str:
+        # only search env var if not force authentication
+        if not self._force:
+            uipath_url = os.getenv("UIPATH_URL")
+            if uipath_url and environment == "cloud":  # "cloud" is the default
+                parsed_url = urlparse(uipath_url)
+                if parsed_url.scheme and parsed_url.netloc:
+                    environment = f"{parsed_url.scheme}://{parsed_url.netloc}"
+                else:
+                    self._console.error(
+                        f"Malformed UIPATH_URL: '{uipath_url}'. Please ensure it includes both scheme and netloc (e.g., 'https://cloud.uipath.com')."
+                    )
+        return environment
+
+    def authenticate(self) -> None:
+        if self._client_id and self._client_secret:
+            self._authenticate_client_credentials()
+            return
+
+        self._authenticate_authorization_code()
+
+    def _authenticate_client_credentials(self) -> None:
+        if not self._base_url:
+            self._console.error(
+                "--base-url is required when using client credentials authentication."
+            )
+            return
+        self._console.hint("Using client credentials authentication.")
+        credentials_service = ClientCredentialsService(self._base_url)
+        credentials_service.authenticate(
+            self._client_id,  # type: ignore
+            self._client_secret,  # type: ignore
+            self._scope,
+        )
+
+    def _authenticate_authorization_code(self) -> None:
+        with PortalService(self._domain) as portal_service:
+            if not self._force:
+                # use existing env vars
+                if (
+                    os.getenv("UIPATH_URL")
+                    and os.getenv("UIPATH_TENANT_ID")
+                    and os.getenv("UIPATH_ORGANIZATION_ID")
+                ):
+                    try:
+                        portal_service.ensure_valid_token()
+                        return
+                    except Exception:
+                        self._console.error(
+                            "Authentication token is invalid. Please reauthenticate using the '--force' flag.",
+                        )
+            auth_url, code_verifier, state = OidcUtils.get_auth_url(self._domain)
+            webbrowser.open(auth_url, 1)
+            auth_config = OidcUtils.get_auth_config()
+
+            self._console.link(
+                "If a browser window did not open, please open the following URL in your browser:",
+                auth_url,
+            )
+            server = HTTPServer(port=auth_config["port"])
+            token_data = asyncio.run(server.start(state, code_verifier, self._domain))
+
+            if not token_data:
+                self._console.error(
+                    "Authentication failed. Please try again.",
+                )
+
+            portal_service.update_token_data(token_data)
+            update_auth_file(token_data)
+            access_token = token_data["access_token"]
+            update_env_file({"UIPATH_ACCESS_TOKEN": access_token})
+
+            tenants_and_organizations = portal_service.get_tenants_and_organizations()
+            base_url = select_tenant(self._domain, tenants_and_organizations)
+            try:
+                portal_service.post_auth(base_url)
+            except Exception:
+                self._console.error(
+                    "Could not prepare the environment. Please try again.",
+                )
+
+    def set_port(self):
+        def is_port_in_use(target_port: int) -> bool:
+            with socket(AF_INET, SOCK_STREAM) as s:
+                try:
+                    s.bind(("localhost", target_port))
+                    s.close()
+                    return False
+                except error:
+                    return True
+
+        auth_config = OidcUtils.get_auth_config()
+        port = int(auth_config.get("port", 8104))
+        port_option_one = int(auth_config.get("portOptionOne", 8104))  # type: ignore
+        port_option_two = int(auth_config.get("portOptionTwo", 8055))  # type: ignore
+        port_option_three = int(auth_config.get("portOptionThree", 42042))  # type: ignore
+        if is_port_in_use(port):
+            if is_port_in_use(port_option_one):
+                if is_port_in_use(port_option_two):
+                    if is_port_in_use(port_option_three):
+                        self._console.error(
+                            "All configured ports are in use. Please close applications using ports or configure different ports."
+                        )
+                    else:
+                        port = port_option_three
+                else:
+                    port = port_option_two
+            else:
+                port = port_option_one
+        auth_config["port"] = port
+        with open(
+            os.path.join(os.path.dirname(__file__), "..", "auth_config.json"), "w"
+        ) as f:
+            json.dump(auth_config, f)

{uipath-2.1.40 → uipath-2.1.42}/src/uipath/_cli/_auth/_client_credentials.py

@@ -1,4 +1,4 @@
-from typing import Optional
+from typing import Optional, cast
 from urllib.parse import urlparse
 
 import httpx
@@ -14,12 +14,13 @@ console = ConsoleLogger()
 class ClientCredentialsService:
     """Service for client credentials authentication flow."""
 
-    def __init__(self, domain: str):
-        self.domain = domain
+    def __init__(self, base_url: str):
+        self._base_url = base_url
+        self._domain = self._extract_domain_from_base_url(base_url)
 
     def get_token_url(self) -> str:
         """Get the token URL for the specified domain."""
-        match self.domain:
+        match self._domain:
             case "alpha":
                 return "https://alpha.uipath.com/identity_/connect/token"
             case "staging":
@@ -39,7 +40,7 @@ class ClientCredentialsService:
         """
         return hostname == domain or hostname.endswith(f".{domain}")
 
-    def extract_domain_from_base_url(self, base_url: str) -> str:
+    def _extract_domain_from_base_url(self, base_url: str) -> str:
         """Extract domain from base URL.
 
         Args:
@@ -71,7 +72,7 @@ class ClientCredentialsService:
 
     def authenticate(
         self, client_id: str, client_secret: str, scope: Optional[str] = "OR.Execution"
-    ) -> Optional[TokenData]:
+    ) -> None:
         """Authenticate using client credentials flow.
 
         Args:
@@ -97,37 +98,35 @@ class ClientCredentialsService:
                 match response.status_code:
                     case 200:
                         token_data = response.json()
-                        return {
-                            "access_token": token_data["access_token"],
-                            "token_type": token_data.get("token_type", "Bearer"),
-                            "expires_in": token_data.get("expires_in", 3600),
-                            "scope": token_data.get("scope", scope),
-                            # Client credentials flow doesn't provide these, but we need them for compatibility
-                            "refresh_token": "",
-                            "id_token": "",
-                        }
+                        token_data = cast(
+                            TokenData,
+                            {
+                                "access_token": token_data["access_token"],
+                                "token_type": token_data.get("token_type", "Bearer"),
+                                "expires_in": token_data.get("expires_in", 3600),
+                                "scope": token_data.get("scope", scope),
+                                "refresh_token": "",
+                                "id_token": "",
+                            },
+                        )
+                        self._setup_environment(token_data)
                     case 400:
                         console.error(
                             "Invalid client credentials or request parameters."
                         )
-                        return None
                     case 401:
                         console.error("Unauthorized: Invalid client credentials.")
-                        return None
                     case _:
                         console.error(
                             f"Authentication failed: {response.status_code} - {response.text}"
                         )
-                        return None
 
         except httpx.RequestError as e:
             console.error(f"Network error during authentication: {e}")
-            return None
         except Exception as e:
             console.error(f"Unexpected error during authentication: {e}")
-            return None
 
-    def setup_environment(self, token_data: TokenData, base_url: str):
+    def _setup_environment(self, token_data: TokenData):
         """Setup environment variables for client credentials authentication.
 
         Args:
@@ -138,7 +137,7 @@ class ClientCredentialsService:
 
         env_vars = {
             "UIPATH_ACCESS_TOKEN": token_data["access_token"],
-            "UIPATH_URL": base_url,
+            "UIPATH_URL": self._base_url,
             "UIPATH_ORGANIZATION_ID": parsed_access_token.get("prt_id", ""),
             "UIPATH_TENANT_ID": "",
         }

uipath-2.1.42/src/uipath/_cli/_auth/_oidc_utils.py

@@ -0,0 +1,75 @@
+import base64
+import hashlib
+import json
+import os
+from urllib.parse import urlencode
+
+from ._models import AuthConfig
+from ._url_utils import build_service_url
+
+
+def generate_code_verifier_and_challenge():
+    """Generate PKCE code verifier and challenge."""
+    code_verifier = base64.urlsafe_b64encode(os.urandom(32)).decode("utf-8").rstrip("=")
+
+    code_challenge_bytes = hashlib.sha256(code_verifier.encode("utf-8")).digest()
+    code_challenge = (
+        base64.urlsafe_b64encode(code_challenge_bytes).decode("utf-8").rstrip("=")
+    )
+
+    return code_verifier, code_challenge
+
+
+def get_state_param() -> str:
+    return base64.urlsafe_b64encode(os.urandom(32)).decode("utf-8").rstrip("=")
+
+
+class OidcUtils:
+    @classmethod
+    def get_auth_config(cls) -> AuthConfig:
+        with open(
+            os.path.join(os.path.dirname(__file__), "auth_config.json"), "r"
+        ) as f:
+            auth_config = json.load(f)
+
+        port = auth_config.get("port", 8104)
+
+        redirect_uri = auth_config["redirect_uri"].replace(
+            "__PY_REPLACE_PORT__", str(port)
+        )
+
+        return AuthConfig(
+            client_id=auth_config["client_id"],
+            redirect_uri=redirect_uri,
+            scope=auth_config["scope"],
+            port=port,
+        )
+
+    @classmethod
+    def get_auth_url(cls, domain: str) -> tuple[str, str, str]:
+        """Get the authorization URL for OAuth2 PKCE flow.
+
+        Args:
+            domain (str): The UiPath domain to authenticate against (e.g. 'alpha', 'cloud')
+
+        Returns:
+            tuple[str, str]: A tuple containing:
+                - The authorization URL with query parameters
+                - The code verifier for PKCE flow
+        """
+        code_verifier, code_challenge = generate_code_verifier_and_challenge()
+        auth_config = cls.get_auth_config()
+        state = get_state_param()
+        query_params = {
+            "client_id": auth_config["client_id"],
+            "redirect_uri": auth_config["redirect_uri"],
+            "response_type": "code",
+            "scope": auth_config["scope"],
+            "state": state,
+            "code_challenge": code_challenge,
+            "code_challenge_method": "S256",
+        }
+
+        query_string = urlencode(query_params)
+        url = build_service_url(domain, f"/identity_/connect/authorize?{query_string}")
+        return url, code_verifier, state

{uipath-2.1.40 → uipath-2.1.42}/src/uipath/_cli/_auth/_portal_service.py

@@ -8,7 +8,7 @@ import httpx
 from ..._utils._ssl_context import get_httpx_client_kwargs
 from .._utils._console import ConsoleLogger
 from ._models import TenantsAndOrganizationInfoResponse, TokenData
-from ._oidc_utils import get_auth_config
+from ._oidc_utils import OidcUtils
 from ._url_utils import build_service_url, get_base_url
 from ._utils import (
     get_auth_data,
@@ -102,7 +102,7 @@ class PortalService:
             raise RuntimeError("HTTP client is not initialized")
 
         url = build_service_url(self.domain, "/identity_/connect/token")
-        client_id = get_auth_config().get("client_id")
+        client_id = OidcUtils.get_auth_config().get("client_id")
 
         data = {
             "grant_type": "refresh_token",
@@ -136,32 +136,33 @@ class PortalService:
         auth_data = get_auth_data()
         claims = get_parsed_token_data(auth_data)
         exp = claims.get("exp")
-
         if exp is not None and float(exp) > time.time():
             if not os.getenv("UIPATH_URL"):
                 tenants_and_organizations = self.get_tenants_and_organizations()
                 select_tenant(
                     self.domain if self.domain else "alpha", tenants_and_organizations
                 )
-            return auth_data.get("access_token")
-
-        refresh_token = auth_data.get("refresh_token")
-        if refresh_token is None:
-            raise Exception("Refresh token not found")
-        token_data = self.post_refresh_token_request(refresh_token)
-        update_auth_file(token_data)
-
-        self.access_token = token_data["access_token"]
-        self.prt_id = claims.get("prt_id")
-
-        updated_env_contents = {
-            "UIPATH_ACCESS_TOKEN": token_data["access_token"],
-        }
-        if not os.getenv("UIPATH_URL"):
-            tenants_and_organizations = self.get_tenants_and_organizations()
-            select_tenant(
-                self.domain if self.domain else "alpha", tenants_and_organizations
-            )
+            updated_env_contents = {
+                "UIPATH_ACCESS_TOKEN": auth_data["access_token"],
+            }
+        else:
+            refresh_token = auth_data.get("refresh_token")
+            if refresh_token is None:
+                raise Exception("Refresh token not found")
+            token_data = self.post_refresh_token_request(refresh_token)
+            update_auth_file(token_data)
+
+            self.access_token = token_data["access_token"]
+            self.prt_id = claims.get("prt_id")
+
+            updated_env_contents = {
+                "UIPATH_ACCESS_TOKEN": token_data["access_token"],
+            }
+            if not os.getenv("UIPATH_URL"):
+                tenants_and_organizations = self.get_tenants_and_organizations()
+                select_tenant(
+                    self.domain if self.domain else "alpha", tenants_and_organizations
+                )
 
         update_env_file(updated_env_contents)
 

{uipath-2.1.40 → uipath-2.1.42}/src/uipath/_cli/_auth/_url_utils.py

@@ -1,6 +1,8 @@
 import os
 from urllib.parse import urlparse
 
+ignore_env_var = False
+
 
 def get_base_url(domain: str) -> str:
     """Get the base URL for UiPath services.
@@ -11,11 +13,14 @@ def get_base_url(domain: str) -> str:
     Returns:
         The base URL to use for UiPath services
     """
-    # If UIPATH_URL is set and domain is 'cloud' (default), use the base from UIPATH_URL
-    uipath_url = os.getenv("UIPATH_URL")
-    if uipath_url and domain == "cloud":
-        parsed_url = urlparse(uipath_url)
-        return f"{parsed_url.scheme}://{parsed_url.netloc}"
+    global ignore_env_var
+
+    if not ignore_env_var:
+        # If UIPATH_URL is set and domain is 'cloud' (default), use the base from UIPATH_URL
+        uipath_url = os.getenv("UIPATH_URL")
+        if uipath_url and domain == "cloud":
+            parsed_url = urlparse(uipath_url)
+            return f"{parsed_url.scheme}://{parsed_url.netloc}"
 
     # If domain is already a full URL, use it directly
     if domain.startswith("http"):
@@ -25,6 +30,11 @@ def get_base_url(domain: str) -> str:
     return f"https://{domain if domain else 'cloud'}.uipath.com"
 
 
+def set_force_flag(force: bool):
+    global ignore_env_var
+    ignore_env_var = force
+
+
 def build_service_url(domain: str, path: str) -> str:
     """Build a service URL by combining the base URL with a path.
 

{uipath-2.1.40 → uipath-2.1.42}/src/uipath/_cli/_dev/_terminal/__init__.py

@@ -4,7 +4,7 @@ import traceback
 from datetime import datetime
 from os import environ as env
 from pathlib import Path
-from typing import Any, Dict
+from typing import Any, Dict, cast
 from uuid import uuid4
 
 import pyperclip  # type: ignore[import-untyped]
@@ -15,7 +15,12 @@ from textual.binding import Binding
 from textual.containers import Container, Horizontal
 from textual.widgets import Button, Footer, Input, ListView, RichLog
 
-from uipath.agent.conversation import UiPathConversationEvent
+from uipath.agent.conversation import (
+    UiPathConversationContentPart,
+    UiPathConversationEvent,
+    UiPathConversationMessage,
+    UiPathInlineValue,
+)
 
 from ..._runtime._contracts import (
     UiPathErrorContract,
@@ -116,7 +121,8 @@ class UiPathDevTerminal(App[Any]):
 
         details_panel = self.query_one("#details-panel", RunDetailsPanel)
         if details_panel and details_panel.current_run:
-            if details_panel.current_run.status != "suspended":
+            status = details_panel.current_run.status
+            if status == "running":
                 self.app.notify(
                     "Wait for agent response...", timeout=1.5, severity="warning"
                 )
@@ -128,7 +134,22 @@ class UiPathDevTerminal(App[Any]):
                 ),
                 details_panel.current_run.id,
             )
-            details_panel.current_run.resume_data = {"value": user_text}
+            if details_panel.current_run.status == "suspended":
+                details_panel.current_run.resume_data = user_text
+            else:
+                details_panel.current_run.input_data = UiPathConversationMessage(
+                    message_id=str(uuid4()),
+                    created_at=datetime.now().isoformat(),
+                    updated_at=datetime.now().isoformat(),
+                    content_parts=[
+                        UiPathConversationContentPart(
+                            content_part_id=str(uuid4()),
+                            mime_type="text/plain",
+                            data=UiPathInlineValue(inline=user_text),
+                        )
+                    ],
+                    role="user",
+                )
             asyncio.create_task(self._execute_runtime(details_panel.current_run))
             event.input.clear()
 
@@ -147,7 +168,7 @@ class UiPathDevTerminal(App[Any]):
     async def action_execute_run(self) -> None:
         """Execute a new run with UiPath runtime."""
         new_run_panel = self.query_one("#new-run-panel", NewRunPanel)
-        entrypoint, input_data = new_run_panel.get_input_values()
+        entrypoint, input_data, conversational = new_run_panel.get_input_values()
 
         if not entrypoint:
             return
@@ -158,7 +179,7 @@ class UiPathDevTerminal(App[Any]):
         except json.JSONDecodeError:
             return
 
-        run = ExecutionRun(entrypoint, input)
+        run = ExecutionRun(entrypoint, input, conversational)
 
         self.runs[run.id] = run
 
@@ -166,7 +187,10 @@ class UiPathDevTerminal(App[Any]):
 
         self._show_run_details(run)
 
-        asyncio.create_task(self._execute_runtime(run))
+        if not run.conversational:
+            asyncio.create_task(self._execute_runtime(run))
+        else:
+            self._focus_chat_input()
 
     async def action_clear_history(self) -> None:
         """Clear run history."""
@@ -191,6 +215,7 @@ class UiPathDevTerminal(App[Any]):
                 entrypoint=run.entrypoint,
                 trace_id=str(uuid4()),
                 execution_id=run.id,
+                is_conversational=run.conversational,
                 logs_min_level=env.get("LOG_LEVEL", "INFO"),
                 log_handler=RunContextLogHandler(
                     run_id=run.id, callback=self._handle_log_message
@@ -201,11 +226,16 @@ class UiPathDevTerminal(App[Any]):
             )
 
             if run.status == "suspended":
-                context.resume = True
                 context.input_json = run.resume_data
+                context.resume = True
                 self._add_info_log(run, f"Resuming execution: {run.entrypoint}")
             else:
-                context.input_json = run.input_data
+                if run.conversational:
+                    context.input_message = cast(
+                        UiPathConversationMessage, run.input_data
+                    )
+                else:
+                    context.input_json = run.input_data
                 self._add_info_log(run, f"Starting execution: {run.entrypoint}")
 
             run.status = "running"
@@ -214,7 +244,10 @@ class UiPathDevTerminal(App[Any]):
             result = await self.runtime_factory.execute_in_root_span(context)
 
             if result is not None:
-                if result.status == UiPathRuntimeStatus.SUSPENDED.value:
+                if (
+                    result.status == UiPathRuntimeStatus.SUSPENDED.value
+                    and result.resume
+                ):
                     run.status = "suspended"
                 else:
                     run.output_data = result.output
@@ -254,6 +287,13 @@ class UiPathDevTerminal(App[Any]):
         # Populate the details panel with run data
         details_panel.update_run(run)
 
+    def _focus_chat_input(self):
+        """Focus the chat input box."""
+        details_panel = self.query_one("#details-panel", RunDetailsPanel)
+        details_panel.switch_tab("chat-tab")
+        chat_input = details_panel.query_one("#chat-input", Input)
+        chat_input.focus()
+
     def _add_run_in_history(self, run: ExecutionRun):
         """Add run to history panel."""
         history_panel = self.query_one("#history-panel", RunHistoryPanel)

{uipath-2.1.40 → uipath-2.1.42}/src/uipath/_cli/_dev/_terminal/_components/_chat.py

@@ -1,10 +1,11 @@
 import time
-from typing import Dict, List, Union
+from typing import Dict, List, Optional, Union
 
 from textual.app import ComposeResult
 from textual.containers import Container, Vertical, VerticalScroll
 from textual.widgets import Input, Markdown
 
+from uipath._cli._dev._terminal._models._execution import ExecutionRun
 from uipath.agent.conversation import (
     UiPathConversationEvent,
     UiPathConversationMessage,
@@ -44,8 +45,22 @@ class ChatPanel(Container):
                 id="chat-input",
             )
 
+    def update_messages(self, run: ExecutionRun) -> None:
+        """Update the chat panel with messages from the given execution run."""
+        chat_view = self.query_one("#chat-view")
+        chat_view.remove_children()
+        self._chat_widgets.clear()
+        self._last_update_time.clear()
+
+        for chat_msg in run.messages:
+            self.add_chat_message(None, chat_msg, auto_scroll=False)
+        chat_view.scroll_end(animate=False)
+
     def add_chat_message(
-        self, event: UiPathConversationEvent, chat_msg: UiPathConversationMessage
+        self,
+        event: Optional[UiPathConversationEvent],
+        chat_msg: UiPathConversationMessage,
+        auto_scroll: bool = True,
     ) -> None:
         """Add or update a chat message bubble."""
         chat_view = self.query_one("#chat-view")
@@ -90,17 +105,20 @@ class ChatPanel(Container):
 
         if existing:
             should_update = (
-                event.exchange
+                event
+                and event.exchange
                 and event.exchange.message
                 and event.exchange.message.end is not None
             )
             if should_update or now - last_update > 0.15:
                 existing.update(content)
                 self._last_update_time[chat_msg.message_id] = now
-                chat_view.scroll_end(animate=False)
+                if auto_scroll:
+                    chat_view.scroll_end(animate=False)
         else:
             widget_instance = widget_cls(content)
             chat_view.mount(widget_instance)
             self._chat_widgets[chat_msg.message_id] = widget_instance
             self._last_update_time[chat_msg.message_id] = now
-            chat_view.scroll_end(animate=False)
+            if auto_scroll:
+                chat_view.scroll_end(animate=False)