uipath 2.0.0.dev2__py3-none-any.whl → 2.0.1.dev1__py3-none-any.whl

uipath/__init__.py

@@ -0,0 +1,24 @@
+"""UiPath SDK for Python.
+
+This package provides a Python interface to interact with UiPath's automation platform.
+
+
+The main entry point is the UiPath class, which provides access to all SDK functionality.
+
+Example:
+```python
+    # First set these environment variables:
+    # export UIPATH_URL="https://cloud.uipath.com/organization-name/default-tenant"
+    # export UIPATH_ACCESS_TOKEN="your_**_token"
+    # export UIPATH_FOLDER_PATH="your/folder/path"
+
+    from uipath import UiPath
+    sdk = UiPath()
+    # Invoke a process by name
+    sdk.processes.invoke("MyProcess")
+```
+"""
+
+from ._uipath import UiPath
+
+__all__ = ["UiPath"]

uipath/_cli/README.md

@@ -0,0 +1,11 @@
+# parse
+
+`parse-ast.py` will extract names and types of resources to prepare for bindings. currently it's hardcoded to run on `dummy-main.py`
+
+# init
+
+asks for project name, type (process/agent) description and target directory where to init the project. it inits a script, a requirements.txt for the user to install, and a config.json file that we'll use at packing time.
+
+# pack
+
+asks for target directory of the package files and the version and will create a nupkg file

uipath/_cli/__init__.py

@@ -0,0 +1,54 @@
+import importlib.metadata
+import sys
+
+import click
+
+from .cli_auth import auth as auth  # type: ignore
+from .cli_deploy import deploy as deploy  # type: ignore
+from .cli_init import init as init  # type: ignore
+from .cli_new import new as new  # type: ignore
+from .cli_pack import pack as pack  # type: ignore
+from .cli_publish import publish as publish  # type: ignore
+from .cli_run import run as run  # type: ignore
+
+
+@click.group(invoke_without_command=True)
+@click.version_option(
+    importlib.metadata.version("uipath"),
+    prog_name="uipath",
+    message="%(prog)s version %(version)s",
+)
+@click.option(
+    "-lv",
+    is_flag=True,
+    help="Display the current version of uipath-langchain.",
+)
+@click.option(
+    "-v",
+    is_flag=True,
+    help="Display the current version of uipath.",
+)
+def cli(lv: bool, v: bool) -> None:
+    if lv:
+        try:
+            version = importlib.metadata.version("uipath-langchain")
+            click.echo(f"uipath-langchain version {version}")
+        except importlib.metadata.PackageNotFoundError:
+            click.echo("uipath-langchain is not installed", err=True)
+            sys.exit(1)
+    if v:
+        try:
+            version = importlib.metadata.version("uipath")
+            click.echo(f"uipath version {version}")
+        except importlib.metadata.PackageNotFoundError:
+            click.echo("uipath is not installed", err=True)
+            sys.exit(1)
+
+
+cli.add_command(new)
+cli.add_command(init)
+cli.add_command(pack)
+cli.add_command(publish)
+cli.add_command(run)
+cli.add_command(deploy)
+cli.add_command(auth)

uipath/_cli/_auth/_auth_server.py

@@ -0,0 +1,165 @@
+import http.server
+import json
+import os
+import socketserver
+import ssl
+import time
+
+from dotenv import load_dotenv
+
+from ._oidc_utils import get_auth_config
+
+load_dotenv()
+
+# Server port
+PORT = 6234
+
+
+# Custom exception for token received
+class TokenReceivedSignal(Exception):
+    """Exception raised when a token is successfully received."""
+
+    def __init__(self, token_data):
+        self.token_data = token_data
+        super().__init__("Token received successfully")
+
+
+def make_request_handler_class(state, code_verifier, token_callback, domain):
+    class SimpleHTTPSRequestHandler(http.server.SimpleHTTPRequestHandler):
+        """Simple HTTPS request handler that serves static files."""
+
+        def log_message(self, format, *args) -> None:
+            # do nothing
+            pass
+
+        def do_POST(self):
+            """Handle POST requests to /set_token."""
+            if self.path == "/set_token":
+                content_length = int(self.headers["Content-Length"])
+                post_data = self.rfile.read(content_length)
+                token_data = json.loads(post_data.decode("utf-8"))
+                print("Received authentication information")
+
+                self.send_response(200)
+                self.end_headers()
+                self.wfile.write(b"Token received")
+
+                time.sleep(1)
+
+                token_callback(token_data)
+            elif self.path == "/log":
+                content_length = int(self.headers["Content-Length"])
+                post_data = self.rfile.read(content_length)
+                logs = json.loads(post_data.decode("utf-8"))
+                # Write logs to .uipath/.error_log file
+                uipath_dir = os.path.join(os.getcwd(), ".uipath")
+                os.makedirs(uipath_dir, exist_ok=True)
+                error_log_path = os.path.join(uipath_dir, ".error_log")
+
+                with open(error_log_path, "a", encoding="utf-8") as f:
+                    f.write(
+                        f"\n--- Authentication Error Log {time.strftime('%Y-%m-%d %H:%M:%S')} ---\n"
+                    )
+                    json.dump(logs, f, indent=2)
+                    f.write("\n")
+                print(logs)
+                print("Received log data")
+                self.send_response(200)
+                self.end_headers()
+                self.wfile.write(b"Log received")
+            else:
+                self.send_error(404, "Path not found")
+
+        def do_GET(self):
+            """Handle GET requests by serving index.html."""
+            # Always serve index.html regardless of the path
+            try:
+                index_path = os.path.join(os.path.dirname(__file__), "index.html")
+                with open(index_path, "r") as f:
+                    content = f.read()
+
+                # Get the redirect URI from auth config
+                auth_config = get_auth_config()
+                redirect_uri = auth_config["redirect_uri"]
+
+                content = content.replace("__PY_REPLACE_EXPECTED_STATE__", state)
+                content = content.replace("__PY_REPLACE_CODE_VERIFIER__", code_verifier)
+                content = content.replace("__PY_REPLACE_REDIRECT_URI__", redirect_uri)
+                content = content.replace(
+                    "__PY_REPLACE_CLIENT_ID__", auth_config["client_id"]
+                )
+                content = content.replace("__PY_REPLACE_DOMAIN__", domain)
+
+                self.send_response(200)
+                self.send_header("Content-Type", "text/html")
+                self.send_header("Content-Length", str(len(content)))
+                self.end_headers()
+                self.wfile.write(content.encode("utf-8"))
+            except FileNotFoundError:
+                self.send_error(404, "File not found")
+
+        def end_headers(self):
+            self.send_header("Access-Control-Allow-Origin", "*")
+            self.send_header("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
+            self.send_header("Access-Control-Allow-Headers", "Content-Type")
+            super().end_headers()
+
+        def do_OPTIONS(self):
+            self.send_response(200)
+            self.end_headers()
+
+    return SimpleHTTPSRequestHandler
+
+
+class HTTPSServer:
+    def __init__(self, port=6234, cert_file="localhost.crt", key_file="localhost.key"):
+        """Initialize HTTPS server with configurable parameters."""
+        self.current_path = os.path.dirname(os.path.abspath(__file__))
+        self.port = port
+        self.cert_file = os.path.join(self.current_path, "localhost.crt")
+        self.key_file = os.path.join(self.current_path, "localhost.key")
+        self.httpd = None
+        self.token_data = None
+        self.should_shutdown = False
+
+    def token_received_callback(self, token_data):
+        """Callback for when a token is received."""
+        self.token_data = token_data
+        self.should_shutdown = True
+
+    def create_server(self, state, code_verifier, domain):
+        """Create and configure the HTTPS server."""
+        # Create SSL context
+        context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
+        context.load_cert_chain(self.cert_file, self.key_file)
+
+        # Create server
+        handler = make_request_handler_class(
+            state, code_verifier, self.token_received_callback, domain
+        )
+        self.httpd = socketserver.TCPServer(("", self.port), handler)
+        self.httpd.socket = context.wrap_socket(self.httpd.socket, server_side=True)
+
+        return self.httpd
+
+    def start(self, state, code_verifier, domain):
+        """Start the server."""
+        if not self.httpd:
+            self.create_server(state, code_verifier, domain)
+
+        try:
+            if self.httpd:
+                while not self.should_shutdown:
+                    self.httpd.handle_request()
+        except KeyboardInterrupt:
+            print("Process interrupted by user")
+        finally:
+            self.stop()
+
+        return self.token_data if self.token_data else {}
+
+    def stop(self):
+        """Stop the server gracefully."""
+        if self.httpd:
+            self.httpd.server_close()
+            self.httpd = None

uipath/_cli/_auth/_models.py

@@ -0,0 +1,51 @@
+from typing import TypedDict
+
+
+class AuthConfig(TypedDict):
+    """TypedDict for auth_config.json structure."""
+
+    client_id: str
+    port: int
+    redirect_uri: str
+    scope: str
+
+
+class TokenData(TypedDict):
+    """TypedDict for token data structure."""
+
+    access_token: str
+    refresh_token: str
+    expires_in: int
+    token_type: str
+    scope: str
+    id_token: str
+
+
+class AccessTokenData(TypedDict):
+    """TypedDict for access token data structure."""
+
+    sub: str
+    prt_id: str
+    client_id: str
+    exp: float
+
+
+class TenantInfo(TypedDict):
+    """TypedDict for tenant info structure."""
+
+    name: str
+    id: str
+
+
+class OrganizationInfo(TypedDict):
+    """TypedDict for organization info structure."""
+
+    id: str
+    name: str
+
+
+class TenantsAndOrganizationInfoResponse(TypedDict):
+    """TypedDict for tenants and organization info response structure."""
+
+    tenants: list[TenantInfo]
+    organization: OrganizationInfo

uipath/_cli/_auth/_oidc_utils.py

@@ -0,0 +1,69 @@
+import base64
+import hashlib
+import json
+import os
+from urllib.parse import urlencode
+
+from ._models import AuthConfig
+
+
+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("=")
+
+
+def get_auth_config() -> AuthConfig:
+    auth_config = {}
+    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,
+    )
+
+
+def get_auth_url(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 = 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 = f"https://{domain}.uipath.com/identity_/connect/authorize?{query_string}"
+    return url, code_verifier, state

uipath/_cli/_auth/_portal_service.py

@@ -0,0 +1,163 @@
+import os
+import time
+from typing import Optional
+
+import click
+import requests
+
+from ._models import TenantsAndOrganizationInfoResponse, TokenData
+from ._oidc_utils import get_auth_config
+from ._utils import (
+    get_auth_data,
+    get_parsed_token_data,
+    update_auth_file,
+    update_env_file,
+)
+
+
+class PortalService:
+    """Service for interacting with the UiPath Portal API."""
+
+    access_token: Optional[str] = None
+    prt_id: Optional[str] = None
+    domain: Optional[str] = None
+    selected_tenant: Optional[str] = None
+
+    _tenants_and_organizations: Optional[TenantsAndOrganizationInfoResponse] = None
+
+    def __init__(
+        self,
+        domain: str,
+        access_token: Optional[str] = None,
+        prt_id: Optional[str] = None,
+    ):
+        self.domain = domain
+        self.access_token = access_token
+        self.prt_id = prt_id
+
+    def update_token_data(self, token_data: TokenData):
+        self.access_token = token_data["access_token"]
+        self.prt_id = get_parsed_token_data(token_data).get("prt_id")
+
+    def get_tenants_and_organizations(self) -> TenantsAndOrganizationInfoResponse:
+        url = f"https://{self.domain}.uipath.com/{self.prt_id}/portal_/api/filtering/leftnav/tenantsAndOrganizationInfo"
+        response = requests.get(
+            url, headers={"Authorization": f"Bearer {self.access_token}"}
+        )
+        if response.ok:
+            result = response.json()
+            self._tenants_and_organizations = result
+            return result
+        elif response.status_code == 401:
+            raise Exception("Unauthorized")
+        else:
+            raise Exception(
+                f"Failed to get tenants and organizations: {response.status_code} {response.text}"
+            )
+
+    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:
+            raise Exception("Organization not found")
+        account_name = organization.get("name")
+        return f"https://{self.domain}.uipath.com/{account_name}/{self.selected_tenant}/orchestrator_"
+
+    def post_refresh_token_request(self, refresh_token: str) -> TokenData:
+        url = f"https://{self.domain}.uipath.com/identity_/connect/token"
+        client_id = get_auth_config().get("client_id")
+
+        data = {
+            "grant_type": "refresh_token",
+            "refresh_token": refresh_token,
+            "client_id": client_id,
+        }
+
+        headers = {"Content-Type": "application/x-www-form-urlencoded"}
+
+        response = requests.post(url, data=data, headers=headers)
+        if response.ok:
+            return response.json()
+        elif response.status_code == 401:
+            raise Exception("Unauthorized")
+        else:
+            raise Exception(f"Failed to refresh token: {response.status_code}")
+
+    def ensure_valid_token(self):
+        """Ensure the access token is valid and refresh it if necessary.
+
+        This function should be called when running CLI commands to verify authentication.
+        It checks if an auth file exists and contains a valid non-expired token.
+        If the token is expired, it will attempt to refresh it.
+        If no auth file exists, it will raise an exception.
+
+        Raises:
+            Exception: If no auth file exists or token refresh fails
+        """
+        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
+            )
+
+        update_env_file(updated_env_contents)
+
+    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"]]
+    click.echo("Available tenants:")
+    for idx, name in enumerate(tenant_names):
+        click.echo(f"  {idx}: {name}")
+    tenant_idx = click.prompt("Select tenant", type=int)
+    tenant_name = tenant_names[tenant_idx]
+    account_name = tenants_and_organizations["organization"]["name"]
+    click.echo(f"Selected tenant: {tenant_name}")
+
+    update_env_file(
+        {
+            "UIPATH_URL": f"https://{domain if domain else 'alpha'}.uipath.com/{account_name}/{tenant_name}",
+            "UIPATH_TENANT_ID": tenants_and_organizations["tenants"][tenant_idx]["id"],
+            "UIPATH_ORG_ID": tenants_and_organizations["organization"]["id"],
+        }
+    )

uipath/_cli/_auth/_utils.py

@@ -0,0 +1,51 @@
+import base64
+import json
+import os
+from pathlib import Path
+from typing import Optional
+
+from ._models import AccessTokenData, TokenData
+
+
+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)
+
+
+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)
+
+
+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)

uipath/_cli/_auth/auth_config.json

@@ -0,0 +1,6 @@
+{
+  "client_id": "36dea5b8-e8bb-423d-8e7b-c808df8f1c00",
+  "redirect_uri": "https://localhost:__PY_REPLACE_PORT__/oidc/login",
+  "scope": "offline_access OrchestratorApiUserAccess ConnectionService DataService DocumentUnderstanding EnterpriseContextService Directory JamJamApi LLMGateway LLMOps OMS",
+  "port": 8104
+}