uipath 2.1.79__py3-none-any.whl → 2.1.81__py3-none-any.whl

uipath/_cli/_auth/_portal_service.py

@@ -1,24 +1,27 @@
-import os
 import time
 from typing import Optional
 
 import click
 import httpx
 
+from ..._utils._auth import update_env_file
 from ..._utils._ssl_context import get_httpx_client_kwargs
+from ...models.auth import TokenData
+from .._runtime._contracts import UiPathErrorCategory, UiPathRuntimeError
 from .._utils._console import ConsoleLogger
-from ._models import TenantsAndOrganizationInfoResponse, TokenData
+from ._models import (
+    OrganizationInfo,
+    TenantInfo,
+    TenantsAndOrganizationInfoResponse,
+)
 from ._oidc_utils import OidcUtils
-from ._url_utils import build_service_url, get_base_url
+from ._url_utils import build_service_url
 from ._utils import (
     get_auth_data,
     get_parsed_token_data,
     update_auth_file,
-    update_env_file,
 )
 
-console = ConsoleLogger()
-
 
 class PortalService:
     """Service for interacting with the UiPath Portal API."""
@@ -29,7 +32,6 @@ class PortalService:
     selected_tenant: Optional[str] = None
 
     _client: Optional[httpx.Client] = None
-
     _tenants_and_organizations: Optional[TenantsAndOrganizationInfoResponse] = None
 
     def __init__(
@@ -41,8 +43,15 @@ class PortalService:
         self.domain = domain
         self.access_token = access_token
         self.prt_id = prt_id
+        self._console = ConsoleLogger()
+        self._tenants_and_organizations = None
+        self._client = None
 
-        self._client = httpx.Client(**get_httpx_client_kwargs())
+    @property
+    def client(self) -> httpx.Client:
+        if self._client is None:
+            self._client = httpx.Client(**get_httpx_client_kwargs())
+        return self._client
 
     def close(self):
         """Explicitly close the HTTP client."""
@@ -59,48 +68,35 @@ class PortalService:
         self.close()
 
     def update_token_data(self, token_data: TokenData):
-        self.access_token = token_data["access_token"]
+        self.access_token = token_data.access_token
         self.prt_id = get_parsed_token_data(token_data).get("prt_id")
+        update_auth_file(token_data)
 
-    def get_tenants_and_organizations(self) -> TenantsAndOrganizationInfoResponse:
-        if self._client is None:
-            raise RuntimeError("HTTP client is not initialized")
+    def get_tenants_and_organizations(
+        self,
+    ):
+        if self._tenants_and_organizations is not None:
+            return self._tenants_and_organizations
 
         url = build_service_url(
             self.domain,
             f"/{self.prt_id}/portal_/api/filtering/leftnav/tenantsAndOrganizationInfo",
         )
-        response = self._client.get(
+        response = self.client.get(
             url, headers={"Authorization": f"Bearer {self.access_token}"}
         )
         if response.status_code < 400:
-            result = response.json()
-            self._tenants_and_organizations = result
-            return result
-        elif response.status_code == 401:
-            console.error("Unauthorized")
-        else:
-            console.error(
-                f"Failed to get tenants and organizations: {response.status_code} {response.text}"
-            )
-        # Can't reach here, console.error exits, linting
-        raise Exception("Failed to get tenants")
+            self._tenants_and_organizations = response.json()
+            return self._tenants_and_organizations
 
-    def get_uipath_orchestrator_url(self) -> str:
-        if self._tenants_and_organizations is None:
-            self._tenants_and_organizations = self.get_tenants_and_organizations()
-        organization = self._tenants_and_organizations.get("organization")
-        if organization is None:
-            console.error("Organization not found.")
-            return ""
-        account_name = organization.get("name")
-        base_url = get_base_url(self.domain)
-        return f"{base_url}/{account_name}/{self.selected_tenant}/orchestrator_"
+        if response.status_code == 401:
+            self._console.error("Unauthorized")
 
-    def post_refresh_token_request(self, refresh_token: str) -> TokenData:
-        if self._client is None:
-            raise RuntimeError("HTTP client is not initialized")
+        self._console.error(
+            f"Failed to get tenants and organizations: {response.status_code} {response.text}"
+        )
 
+    def refresh_access_token(self, refresh_token: str) -> TokenData:  # type: ignore
         url = build_service_url(self.domain, "/identity_/connect/token")
         client_id = OidcUtils.get_auth_config().get("client_id")
 
@@ -111,16 +107,14 @@ class PortalService:
         }
 
         headers = {"Content-Type": "application/x-www-form-urlencoded"}
-
-        response = self._client.post(url, data=data, headers=headers)
+        response = self.client.post(url, data=data, headers=headers)
         if response.status_code < 400:
-            return response.json()
-        elif response.status_code == 401:
-            console.error("Unauthorized")
-        else:
-            console.error(f"Failed to refresh token: {response.status_code}")
-        # Can't reach here, console.error exits, linting
-        raise Exception("Failed to refresh get token")
+            return TokenData.model_validate(response.json())
+
+        if response.status_code == 401:
+            self._console.error("Unauthorized")
+
+        self._console.error(f"Failed to refresh token: {response.status_code}")
 
     def ensure_valid_token(self):
         """Ensure the access token is valid and refresh it if necessary.
@@ -136,127 +130,101 @@ 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
-                )
-            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)
+        def finalize(token_data: TokenData):
+            self.update_token_data(token_data)
+            update_env_file({"UIPATH_ACCESS_TOKEN": token_data.access_token})
 
-    def post_auth(self, base_url: str) -> None:
-        if self._client is None:
-            raise RuntimeError("HTTP client is not initialized")
+        if exp is not None and float(exp) > time.time():
+            finalize(auth_data)
+            return
+
+        refresh_token = auth_data.refresh_token
+        if not refresh_token:
+            raise UiPathRuntimeError(
+                "REFRESH_TOKEN_MISSING",
+                "No refresh token found",
+                "The refresh token could not be retrieved. Please retry authenticating.",
+                UiPathErrorCategory.SYSTEM,
+            )
 
-        or_base_url = (
-            f"{base_url}/orchestrator_"
-            if base_url
-            else self.get_uipath_orchestrator_url()
-        )
+        token_data = self.refresh_access_token(refresh_token)
+        finalize(token_data)
 
-        url_try_enable_first_run = f"{or_base_url}/api/StudioWeb/TryEnableFirstRun"
-        url_acquire_license = f"{or_base_url}/api/StudioWeb/AcquireLicense"
+    def enable_studio_web(self, base_url: str) -> None:
+        or_base_url = self.build_orchestrator_url(base_url)
 
-        try:
-            [try_enable_first_run_response, acquire_license_response] = [
-                self._client.post(
-                    url,
-                    headers={"Authorization": f"Bearer {self.access_token}"},
-                )
-                for url in [url_try_enable_first_run, url_acquire_license]
-            ]
-        except Exception:
-            pass
-
-    def has_initialized_auth(self):
-        try:
-            auth_data = get_auth_data()
-            if not auth_data or "access_token" not in auth_data:
-                return False
-            if not os.path.exists(".env"):
-                return False
-            if not os.getenv("UIPATH_ACCESS_TOKEN"):
-                return False
-
-            return True
-        except Exception:
-            return False
-
-
-def select_tenant(
-    domain: str, tenants_and_organizations: TenantsAndOrganizationInfoResponse
-):
-    tenant_names = [tenant["name"] for tenant in tenants_and_organizations["tenants"]]
-    console.display_options(tenant_names, "Select tenant:")
-    tenant_idx = (
-        0
-        if len(tenant_names) == 1
-        else console.prompt("Select tenant number", type=int)
-    )
-    tenant_name = tenant_names[tenant_idx]
-    account_name = tenants_and_organizations["organization"]["name"]
-    console.info(f"Selected tenant: {click.style(tenant_name, fg='cyan')}")
-
-    base_url = get_base_url(domain)
-    uipath_url = f"{base_url}/{account_name}/{tenant_name}"
-
-    update_env_file(
-        {
-            "UIPATH_URL": uipath_url,
-            "UIPATH_TENANT_ID": tenants_and_organizations["tenants"][tenant_idx]["id"],
-            "UIPATH_ORGANIZATION_ID": tenants_and_organizations["organization"]["id"],
-        }
-    )
+        urls = [
+            f"{or_base_url}/api/StudioWeb/TryEnableFirstRun",
+            f"{or_base_url}/api/StudioWeb/AcquireLicense",
+        ]
 
-    return uipath_url
+        for url in urls:
+            try:
+                resp = self.client.post(
+                    url, headers={"Authorization": f"Bearer {self.access_token}"}
+                )
+                if resp.status_code >= 400:
+                    self._console.warning(f"Call to {url} failed: {resp.status_code}")
+            except httpx.HTTPError as e:
+                self._console.warning(
+                    f"Exception during enable_studio_web request to {url}: {e}"
+                )
 
+    def _set_tenant(self, tenant: TenantInfo, organization: OrganizationInfo):
+        self.selected_tenant = tenant["name"]
+        return {"tenant_id": tenant["id"], "organization_id": organization["id"]}
 
-def get_tenant_id(
-    domain: str,
-    tenant_name: str,
-    tenants_and_organizations: TenantsAndOrganizationInfoResponse,
-) -> str:
-    tenants = tenants_and_organizations["tenants"]
+    def _select_tenant(self):
+        data = self.get_tenants_and_organizations()
+        organization = data["organization"]
+        tenants = data["tenants"]
 
-    matched_tenant = next((t for t in tenants if t["name"] == tenant_name), None)
-    if not matched_tenant:
-        console.error(f"Tenant '{tenant_name}' not found.")
-        raise ValueError(f"Tenant '{tenant_name}' not found.")
+        tenant_names = [tenant["name"] for tenant in tenants]
 
-    domain = get_base_url(domain)
-    account_name = tenants_and_organizations["organization"]["name"]
+        self._console.display_options(tenant_names, "Select tenant:")
+        tenant_idx = (
+            0
+            if len(tenant_names) == 1
+            else self._console.prompt("Select tenant number", type=int)
+        )
 
-    base_url = get_base_url(domain)
-    uipath_url = f"{base_url}/{account_name}/{tenant_name}"
+        tenant = data["tenants"][tenant_idx]
 
-    update_env_file(
-        {
-            "UIPATH_URL": uipath_url,
-            "UIPATH_TENANT_ID": matched_tenant["id"],
-            "UIPATH_ORGANIZATION_ID": tenants_and_organizations["organization"]["id"],
-        }
-    )
+        self._console.info(f"Selected tenant: {click.style(tenant['name'], fg='cyan')}")
+        return self._set_tenant(tenant, organization)
 
-    return uipath_url
+    def _retrieve_tenant(
+        self,
+        tenant_name: str,
+    ):
+        data = self.get_tenants_and_organizations()
+        organization = data["organization"]
+        tenants = data["tenants"]
+
+        tenant = next((t for t in tenants if t["name"] == tenant_name), None)
+        if not tenant:
+            self._console.error(f"Tenant '{tenant_name}' not found.")
+
+        return self._set_tenant(tenant, organization)  # type: ignore
+
+    def resolve_tenant_info(self, tenant: Optional[str] = None):
+        if tenant:
+            return self._retrieve_tenant(tenant)
+        return self._select_tenant()
+
+    def build_tenant_url(self) -> str:
+        data = self.get_tenants_and_organizations()
+        organization_name = data["organization"]["name"]
+        return f"{self.domain}/{organization_name}/{self.selected_tenant}"
+
+    def build_orchestrator_url(self, base_url: str) -> str:
+        if base_url:
+            return f"{base_url}/orchestrator_"
+        data = self.get_tenants_and_organizations()
+        organization = data.get("organization")
+        if organization is None:
+            self._console.error("Organization not found.")
+            return ""
+        organization_name = organization.get("name")
+        return f"{self.domain}/{organization_name}/{self.selected_tenant}/orchestrator_"

uipath/_cli/_auth/_url_utils.py

@@ -1,51 +1,85 @@
 import os
+from typing import Optional, Tuple
 from urllib.parse import urlparse
 
-ignore_env_var = False
+from .._utils._console import ConsoleLogger
 
+console = ConsoleLogger()
 
-def get_base_url(domain: str) -> str:
-    """Get the base URL for UiPath services.
+
+def resolve_domain(
+    base_url: Optional[str], environment: Optional[str], force: bool = False
+) -> str:
+    """Resolve the UiPath domain, giving priority to base_url when valid.
 
     Args:
-        domain: Either a domain name (e.g., 'cloud', 'alpha') or a full URL from UIPATH_URL
+        base_url: The base URL explicitly provided.
+        environment: The environment name (e.g., 'alpha', 'staging', 'cloud').
+        force: Whether to ignore UIPATH_URL from environment variables.
 
     Returns:
-        The base URL to use for UiPath services
+        A valid base URL for UiPath services.
     """
-    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
+    if not force:
+        # If UIPATH_URL is set, prefer its domain
         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"):
-        return domain
-
-    # Otherwise, construct the URL using the domain
-    return f"https://{domain if domain else 'cloud'}.uipath.com"
+        if uipath_url and environment == "cloud":
+            parsed = urlparse(uipath_url)
+            if parsed.scheme and parsed.netloc:
+                domain = f"{parsed.scheme}://{parsed.netloc}"
+                return domain
+            else:
+                console.error(
+                    f"Malformed UIPATH_URL: '{uipath_url}'. "
+                    "Please ensure it includes scheme and netloc (e.g., 'https://cloud.uipath.com')."
+                )
 
+    # If base_url is a real URL, prefer it
+    if base_url and base_url.startswith("http"):
+        parsed = urlparse(base_url)
+        domain = f"{parsed.scheme}://{parsed.netloc}"
+        if domain:
+            return domain
 
-def set_force_flag(force: bool):
-    global ignore_env_var
-    ignore_env_var = force
+    # Otherwise, fall back to environment
+    return f"https://{environment or 'cloud'}.uipath.com"
 
 
 def build_service_url(domain: str, path: str) -> str:
     """Build a service URL by combining the base URL with a path.
 
     Args:
-        domain: Either a domain name or full URL
+        domain: The domain name
         path: The path to append (should start with /)
 
     Returns:
         The complete service URL
     """
-    base_url = get_base_url(domain)
-    # Remove trailing slash from base_url to avoid double slashes
-    base_url = base_url.rstrip("/")
-    return f"{base_url}{path}"
+    return f"{domain}{path}"
+
+
+def extract_org_tenant(uipath_url: str) -> Tuple[Optional[str], Optional[str]]:
+    """Extract organization and tenant from a UiPath URL.
+
+    Accepts values like:
+      - https://cloud.uipath.com/myOrg/myTenant
+      - https://alpha.uipath.com/myOrg/myTenant/anything_else
+      - cloud.uipath.com/myOrg/myTenant  (scheme will be assumed https)
+
+    Args:
+        uipath_url: The UiPath URL to parse
+
+    Returns:
+        A tuple of (organization, tenant) where:
+          - organization: 'myOrg' or None
+          - tenant: 'myTenant' or None
+
+    Example:
+        >>> extract_org_tenant('https://cloud.uipath.com/myOrg/myTenant')
+        ('myOrg', 'myTenant')
+    """
+    parsed = urlparse(uipath_url if "://" in uipath_url else f"https://{uipath_url}")
+    parts = [p for p in parsed.path.split("/") if p]
+    org = parts[0] if len(parts) >= 1 else None
+    tenant = parts[1] if len(parts) >= 2 else None
+    return org, tenant

uipath/_cli/_auth/_utils.py

@@ -1,51 +1,28 @@
-import base64
 import json
 import os
 from pathlib import Path
 from typing import Optional
 
-from ._models import AccessTokenData, TokenData
+from ..._utils._auth import parse_access_token
+from ...models.auth import TokenData
+from ._models import AccessTokenData
 
 
 def update_auth_file(token_data: TokenData):
     os.makedirs(Path.cwd() / ".uipath", exist_ok=True)
     auth_file = Path.cwd() / ".uipath" / ".auth.json"
     with open(auth_file, "w") as f:
-        json.dump(token_data, f)
+        json.dump(token_data.model_dump(exclude_none=True), f)
 
 
 def get_auth_data() -> TokenData:
     auth_file = Path.cwd() / ".uipath" / ".auth.json"
     if not auth_file.exists():
         raise Exception("No authentication file found")
-    return json.load(open(auth_file))
-
-
-def parse_access_token(access_token: str) -> AccessTokenData:
-    token_parts = access_token.split(".")
-    if len(token_parts) < 2:
-        raise Exception("Invalid access token")
-    payload = base64.urlsafe_b64decode(
-        token_parts[1] + "=" * (-len(token_parts[1]) % 4)
-    )
-    return json.loads(payload)
+    return TokenData.model_validate(json.load(open(auth_file)))
 
 
 def get_parsed_token_data(token_data: Optional[TokenData] = None) -> AccessTokenData:
     if not token_data:
         token_data = get_auth_data()
-    return parse_access_token(token_data["access_token"])
-
-
-def update_env_file(env_contents):
-    env_path = Path.cwd() / ".env"
-    if env_path.exists():
-        with open(env_path, "r") as f:
-            for line in f:
-                if "=" in line:
-                    key, value = line.strip().split("=", 1)
-                    if key not in env_contents:
-                        env_contents[key] = value
-    lines = [f"{key}={value}\n" for key, value in env_contents.items()]
-    with open(env_path, "w") as f:
-        f.writelines(lines)
+    return parse_access_token(token_data.access_token)

uipath/_cli/_evals/_models/_output.py

@@ -58,43 +58,46 @@ class EvaluationRunResultDto(BaseModel):
     model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)
 
     evaluator_name: str
+    evaluator_id: str
     result: EvaluationResultDto
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, serializer, info):
+        data = serializer(self)
+        if isinstance(data, dict):
+            data.pop("evaluatorId", None)
+        return data
+
 
 class EvaluationRunResult(BaseModel):
     model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)
 
-    score: float = 0.0
     evaluation_name: str
     evaluation_run_results: List[EvaluationRunResultDto]
 
-    def compute_average_score(self) -> None:
+    @property
+    def score(self) -> float:
         """Compute average score for this single eval_item."""
         if not self.evaluation_run_results:
-            self.score = 0.0
-            return
+            return 0.0
 
         total_score = sum(dto.result.score for dto in self.evaluation_run_results)
-        self.score = total_score / len(self.evaluation_run_results)
+        return total_score / len(self.evaluation_run_results)
 
 
 class UiPathEvalOutput(BaseModel):
     model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)
 
     evaluation_set_name: str
-    score: float
     evaluation_set_results: List[EvaluationRunResult]
 
-    def compute_average_score(self) -> None:
-        """Compute overall average by calling eval_item.compute_average_score()."""
+    @property
+    def score(self) -> float:
+        """Compute overall average score from evaluation results."""
         if not self.evaluation_set_results:
-            self.score = 0.0
-            return
-
-        for eval_result in self.evaluation_set_results:
-            eval_result.compute_average_score()
+            return 0.0
 
         eval_item_scores = [
             eval_result.score for eval_result in self.evaluation_set_results
         ]
-        self.score = sum(eval_item_scores) / len(eval_item_scores)
+        return sum(eval_item_scores) / len(eval_item_scores)