remotivelabs-cli 0.5.0a1__py3-none-any.whl

remotivelabs/cli/typer/typer_utils.py

@@ -0,0 +1,27 @@
+from typing import Any
+
+import typer
+from click import Context
+from typer.core import TyperGroup
+
+from remotivelabs.cli.utils.console import print_generic_message
+
+
+class OrderCommands(TyperGroup):
+    def list_commands(self, _ctx: Context):  # type: ignore
+        return list(self.commands)
+
+
+def create_typer(**kwargs: Any) -> typer.Typer:
+    """Create a Typer instance with default settings."""
+    return typer.Typer(cls=OrderCommands, no_args_is_help=True, invoke_without_command=True, **kwargs)
+
+
+def create_typer_sorted(**kwargs: Any) -> typer.Typer:
+    """Create a Typer instance with default settings."""
+    return typer.Typer(no_args_is_help=True, invoke_without_command=True, **kwargs)
+
+
+def print_padded(label: str, right_text: str, length: int = 30) -> None:
+    padded_label = label.ljust(length)  # pad to 30 characters
+    print_generic_message(f"{padded_label} {right_text}")

remotivelabs/cli/utils/console.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+import json
+import os
+import sys
+from typing import Any
+
+import grpc
+from rich.console import Console
+
+console = Console(soft_wrap=True)
+err_console = Console(stderr=True, soft_wrap=True)
+
+
+def print_grpc_error(error: grpc.RpcError) -> None:
+    """TODO: remove me"""
+    if error.code() == grpc.StatusCode.UNAUTHENTICATED:
+        is_access_token = os.environ["ACCESS_TOKEN"]
+        if is_access_token is not None and is_access_token == "true":
+            err_console.print(f":boom: [bold red]Authentication failed[/bold red]: {error.details()}")
+            err_console.print("Please login again")
+        else:
+            err_console.print(":boom: [bold red]Authentication failed[/bold red]")
+            err_console.print("Failed to verify api-key")
+    else:
+        err_console.print(f":boom: [bold red]Unexpected error, status code[/bold red]: {error.code()}")
+        err_console.print(error.details())
+    sys.exit(1)
+
+
+def print_newline() -> None:
+    """TODO: remove me"""
+    console.print("\n")
+
+
+def print_url(url: str) -> None:
+    console.print(url, style="bold")
+
+
+def print_unformatted(message: Any) -> None:
+    """TODO: remove me"""
+    console.print(message)
+
+
+def print_unformatted_to_stderr(message: Any) -> None:
+    """TODO: remove me"""
+    err_console.print(message)
+
+
+def print_success(message: str | None = None) -> None:
+    """
+    Print a success message to stdout
+
+    TODO: use stderr instead.
+    """
+    msg = "[bold green]Success![/bold green]"
+    if message:
+        msg += f" {message}"
+    console.print(msg)
+
+
+def print_generic_error(message: str | None = None) -> None:
+    """
+    Print a failure message to stderr
+
+    TODO: rename to print_failure
+    """
+    msg = ":boom: [bold red]Failed[/bold red]"
+    if message:
+        msg += f": {message}"
+    err_console.print(msg)
+
+
+def print_generic_message(message: str) -> None:
+    """
+    Print a message to the user.
+
+    TODO: rename to print_message
+    TODO: use stderr instead.
+    """
+    console.print(f"[bold]{message}[/bold]")
+
+
+def print_hint(message: str) -> None:
+    """
+    Print a hint to stderr.
+
+    Useful when nudging the user to a suitable solution.
+    """
+    err_console.print(f":point_right: [bold]{message}[/bold]")
+
+
+def print_result(result: Any, default: Any = None) -> None:
+    """
+    Print a result to stdout
+
+    TODO: Decide on how to handle output. In broker lib (to_json)?
+    """
+    console.print(json.dumps(result, indent=2, default=default))

remotivelabs/cli/utils/rest_helper.py

@@ -0,0 +1,369 @@
+from __future__ import annotations
+
+import base64
+import json
+import logging
+import os
+import shutil
+import sys
+from importlib.metadata import version
+from pathlib import Path
+from typing import Any, BinaryIO, Dict, List, Optional, Union, cast
+
+import requests
+from requests.exceptions import JSONDecodeError
+from rich.progress import Progress, SpinnerColumn, TextColumn, wrap_file
+
+from remotivelabs.cli.settings import settings
+from remotivelabs.cli.utils import versions
+from remotivelabs.cli.utils.console import (
+    print_generic_error,
+    print_generic_message,
+    print_hint,
+    print_unformatted,
+    print_unformatted_to_stderr,
+)
+
+if "REMOTIVE_CLOUD_HTTP_LOGGING" in os.environ:
+    logging.basicConfig()
+    logging.getLogger().setLevel(logging.DEBUG)
+    requests_log = logging.getLogger("requests.packages.urllib3")
+    requests_log.setLevel(logging.DEBUG)
+    requests_log.propagate = True
+
+
+class RestHelper:
+    """Static Class with various helper functions for the rest API"""
+
+    __base_url = "https://cloud.remotivelabs.com"
+    __frontend_url = __base_url
+    __license_server_base_url = "https://license.cloud.remotivelabs.com"
+
+    if "REMOTIVE_CLOUD_BASE_URL" in os.environ:
+        __base_url = os.environ["REMOTIVE_CLOUD_BASE_URL"]
+        __frontend_url = os.environ["REMOTIVE_CLOUD_BASE_URL"]
+
+    if "REMOTIVE_CLOUD_FRONTEND_BASE_URL" in os.environ:
+        __frontend_url = os.environ["REMOTIVE_CLOUD_FRONTEND_BASE_URL"]
+
+    if "cloud-dev" in __base_url:
+        __license_server_base_url = "https://license.cloud-dev.remotivelabs.com"
+
+    __headers: Dict[str, str] = {"User-Agent": f"remotivelabs-cli/{versions.cli_version()} ({versions.platform_info()})"}
+    __org: str = ""
+
+    __token: str = ""
+
+    def _cli_version(self) -> str:
+        return ""
+
+    @staticmethod
+    def get_cli_version() -> str:
+        return version("remotivelabs-cli")
+
+    @staticmethod
+    def get_base_url() -> str:
+        return RestHelper.__base_url
+
+    @staticmethod
+    def get_base_frontend_url() -> str:
+        return RestHelper.__frontend_url
+
+    @staticmethod
+    def get_license_server_base_url() -> str:
+        return RestHelper.__license_server_base_url
+
+    @staticmethod
+    def get_headers() -> Dict[str, str]:
+        return RestHelper.__headers
+
+    @staticmethod
+    def get_org() -> str:
+        return RestHelper.__org
+
+    @staticmethod
+    def get_token() -> str:
+        return RestHelper.__token
+
+    @staticmethod
+    def ensure_auth_token(quiet: bool = False, access_token: Optional[str] = None) -> None:
+        """
+        TODO: remove setting org, as we already set the default organization as env in remotive.py?
+        TODO: don't sys.exit, raise error instead
+        """
+
+        if "REMOTIVE_CLOUD_ORGANIZATION" not in os.environ:
+            active_account = settings.get_active_account()
+            if active_account:
+                org = active_account.default_organization
+                if org:
+                    os.environ["REMOTIVE_CLOUD_ORGANIZATION"] = org
+
+        token = access_token
+        if not token:
+            token = settings.get_active_token()
+
+            if not token:
+                if quiet:
+                    return
+                print_hint("you are not logged in, please login using [green]remotive cloud auth login[/green]")
+                sys.exit(1)
+
+        RestHelper.__headers["Authorization"] = f"Bearer {token.strip()}"
+
+    @staticmethod
+    def handle_get(  # noqa: PLR0913
+        url: str,
+        params: Any = None,
+        return_response: bool = False,
+        allow_status_codes: List[int] | None = None,
+        progress_label: str = "Fetching...",
+        use_progress_indicator: bool = True,
+        allow_redirects: bool = False,
+        timeout: int = 60,
+        access_token: Optional[str] = None,
+        skip_access_token: bool = False,
+    ) -> requests.Response:
+        # Returns a Response object if succesfull otherwise None
+        if params is None:
+            params = {}
+        if not skip_access_token:
+            RestHelper.ensure_auth_token(access_token=access_token)
+        if use_progress_indicator:
+            with RestHelper.use_progress(progress_label):
+                r = requests.get(
+                    f"{RestHelper.__base_url}{url}",
+                    headers=RestHelper.__headers,
+                    params=params,
+                    timeout=timeout,
+                    allow_redirects=allow_redirects,
+                )
+        else:
+            r = requests.get(
+                f"{RestHelper.__base_url}{url}",
+                headers=RestHelper.__headers,
+                params=params,
+                timeout=timeout,
+                allow_redirects=allow_redirects,
+            )
+
+        if return_response:
+            RestHelper.check_api_result(r, allow_status_codes)
+            return r
+        RestHelper.print_api_result(r)
+        sys.exit(0)
+
+    @staticmethod
+    def has_access(url: str, params: Any = {}, access_token: Optional[str] = None) -> bool:
+        RestHelper.ensure_auth_token(quiet=True, access_token=access_token)
+        r = requests.get(f"{RestHelper.__base_url}{url}", headers=RestHelper.__headers, params=params, timeout=60)
+        if 200 <= r.status_code <= 299:
+            return True
+        return False
+
+    @staticmethod
+    def check_api_result(response: requests.Response, allow_status_codes: List[int] | None = None) -> None:
+        """
+        TODO: don't sys.exit, raise error instead
+        """
+        if response.status_code == 426:  # CLI upgrade
+            print_hint(response.text)
+            sys.exit(1)
+        if response.status_code > 299:
+            if allow_status_codes is not None and response.status_code in allow_status_codes:
+                return
+            print_generic_error(f"Got status code: {response.status_code}")
+            if response.status_code == 401:
+                print_generic_message("Your token is not valid or has expired, please login again or activate another account")
+            else:
+                print_unformatted_to_stderr(response.text)
+            sys.exit(1)
+
+    @staticmethod
+    def print_api_result(response: requests.Response) -> None:
+        """
+        TODO: don't sys.exit, raise error instead
+        TODO: dont print from here, return and let caller print instead
+        """
+        if response.status_code == 426:  # CLI upgrade
+            print_hint(response.text)
+            sys.exit(1)
+
+        if response.status_code >= 200 and response.status_code < 300:
+            if len(response.content) >= 2:
+                try:
+                    print_unformatted(json.dumps(response.json()))
+                except JSONDecodeError:
+                    print_generic_error("Json parse error: Please try again and report if the error persists")
+            sys.exit(0)
+        else:
+            print_generic_error(f"Got status code: {response.status_code}")
+            if response.status_code == 401:
+                print_generic_message("Your token is not valid or has expired, please login again or activate another account")
+            else:
+                print_unformatted_to_stderr(response.text)
+            sys.exit(1)
+
+    @staticmethod
+    def handle_patch(  # noqa: PLR0913
+        url: str,
+        params: Any = {},
+        quiet: bool = False,
+        progress_label: str = "Deleting...",
+        access_token: Optional[str] = None,
+        allow_status_codes: Optional[List[int]] = None,
+    ) -> requests.Response:
+        if allow_status_codes is None:
+            allow_status_codes = []
+        RestHelper.ensure_auth_token(access_token=access_token)
+        with RestHelper.use_progress(progress_label):
+            r = requests.patch(f"{RestHelper.__base_url}{url}", headers=RestHelper.__headers, params=params, timeout=60)
+        if r.status_code in (200, 204):
+            if not quiet:
+                RestHelper.print_api_result(r)
+        elif r.status_code not in allow_status_codes:
+            RestHelper.print_api_result(r)
+        return r
+
+    @staticmethod
+    def handle_delete(  # noqa: PLR0913
+        url: str,
+        params: Any = {},
+        quiet: bool = False,
+        progress_label: str = "Deleting...",
+        access_token: Optional[str] = None,
+        allow_status_codes: Optional[List[int]] = None,
+    ) -> requests.Response:
+        if allow_status_codes is None:
+            allow_status_codes = []
+        RestHelper.ensure_auth_token(access_token=access_token)
+        with RestHelper.use_progress(progress_label):
+            r = requests.delete(f"{RestHelper.__base_url}{url}", headers=RestHelper.__headers, params=params, timeout=60)
+        if r.status_code in (200, 204):
+            if not quiet:
+                RestHelper.print_api_result(r)
+        elif r.status_code not in allow_status_codes:
+            RestHelper.print_api_result(r)
+        return r
+
+    @staticmethod
+    def handle_post(  # noqa: PLR0913
+        url: str,
+        body: Any = None,
+        params: Any = {},
+        progress_label: str = "Processing...",
+        return_response: bool = False,
+        access_token: Optional[str] = None,
+    ) -> requests.Response:
+        # Returns a Response object if succesfull otherwise, None
+
+        RestHelper.ensure_auth_token(access_token=access_token)
+        RestHelper.__headers["content-type"] = "application/json"
+
+        with RestHelper.use_progress(progress_label):
+            r = requests.post(f"{RestHelper.__base_url}{url}", headers=RestHelper.__headers, params=params, data=body, timeout=60)
+
+        if return_response:
+            RestHelper.check_api_result(r)
+            return r
+
+        RestHelper.print_api_result(r)
+        sys.exit(0)
+
+    @staticmethod
+    def handle_put(url: str, body: Any = None, params: Any = {}, return_response: bool = False) -> requests.Response | None:
+        # Returns a Response object if succesfull otherwise, None
+        RestHelper.ensure_auth_token()
+        RestHelper.__headers["content-type"] = "application/json"
+        r = requests.put(f"{RestHelper.__base_url}{url}", headers=RestHelper.__headers, params=params, data=body, timeout=60)
+
+        if return_response:
+            RestHelper.check_api_result(r)
+            return r
+        RestHelper.print_api_result(r)
+        return None
+
+    @staticmethod
+    def upload_file(
+        path: Union[str, Path],
+        url: str,
+        upload_headers: Dict[str, str] | None = None,
+        return_response: bool = False,
+        progress_label: str = "Uploading...",
+    ) -> requests.Response | None:
+        # Returns a Response object if succesfull otherwise, None
+        RestHelper.ensure_auth_token()
+        if upload_headers is not None:
+            RestHelper.__headers.update(upload_headers)
+        with open(path, "rb") as file:
+            with wrap_file(file, os.stat(path).st_size, description=progress_label) as f:
+                r = requests.post(
+                    f"{RestHelper.__base_url}{url}", files={os.path.basename(path): f}, headers=RestHelper.__headers, timeout=60
+                )
+            if return_response:
+                RestHelper.check_api_result(r)
+                return r
+            RestHelper.print_api_result(r)
+        return None
+
+    @staticmethod
+    def upload_file_with_signed_url(
+        path: Union[str, Path],
+        url: str,
+        upload_headers: Dict[str, str],
+        return_response: bool = False,
+        progress_label: str = "Uploading...",
+    ) -> requests.Response | None:
+        # Returns a Response object if succesfull otherwise, None
+        with open(path, "rb") as file:
+            with wrap_file(file, os.stat(path).st_size, description=progress_label, transient=False) as f:
+                r = requests.put(url, data=f, headers=upload_headers, timeout=60)
+            if return_response:
+                RestHelper.check_api_result(r)
+                return r
+            RestHelper.print_api_result(r)
+        return None
+
+    @staticmethod
+    def use_progress(label: str, transient: bool = True) -> Progress:
+        p = Progress(SpinnerColumn(), TextColumn("[progress.description]{task.description}"), transient=transient)
+        p.add_task(label, total=1)
+        return p
+
+    @staticmethod
+    def download_file(save_file_name: Path, url: str) -> None:
+        # Next download the actual file
+        download_resp = requests.get(url=url, stream=True, timeout=60)
+        if download_resp.status_code == 200:
+            content_length = int(download_resp.headers["Content-Length"])
+            with open(save_file_name, "wb") as out_file:
+                stream = cast(BinaryIO, download_resp.raw)  # we know this is a binary stream, as stream=True is set in the request
+                with wrap_file(
+                    stream,
+                    content_length,
+                    refresh_per_second=100,
+                    description=f"Downloading to {save_file_name}",
+                ) as stream_with_progress:
+                    shutil.copyfileobj(stream_with_progress, out_file)
+        else:
+            RestHelper.check_api_result(download_resp)
+
+    @staticmethod
+    def request_license(email: str, machine_id: Dict[str, Any]) -> str:
+        # Lets keep the email here so we have the same interface for both authenticated
+        # and not authenticated license requests.
+        # email will be validated in the license server to make sure it matches with the user of the
+        # access token so not any email is sent here
+        RestHelper.ensure_auth_token()
+        payload = {"id": email, "machine_id": machine_id}
+        b64_encoded_bytes = base64.encodebytes(json.dumps(payload).encode())
+        license_jsonb64 = {"licensejsonb64": b64_encoded_bytes.decode("utf-8")}
+        RestHelper.__headers["content-type"] = "application/json"
+        r = requests.post(
+            url=f"{RestHelper.__license_server_base_url}/api/license/request",
+            headers=RestHelper.__headers,
+            data=json.dumps(license_jsonb64),
+            timeout=60,
+        )
+        RestHelper.check_api_result(r)
+        return str(r.json()["license_data"])

remotivelabs/cli/utils/time.py

@@ -0,0 +1,11 @@
+from datetime import date, datetime
+
+
+def parse_date(date_str: str) -> date:
+    return parse_datetime(date_str).date()
+
+
+def parse_datetime(date_str: str) -> datetime:
+    """Required for pre 3.11"""
+    normalized = date_str.replace("Z", "+00:00")
+    return datetime.fromisoformat(normalized)

remotivelabs/cli/utils/versions.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+import datetime
+import json
+import os
+import platform
+import urllib.request
+from importlib import metadata as importlib_metadata
+from importlib.metadata import version as python_project_version
+
+from packaging.version import InvalidVersion, Version
+
+from remotivelabs.cli.settings import Settings
+from remotivelabs.cli.utils.console import print_hint
+
+
+def cli_version() -> str:
+    return python_project_version("remotivelabs-cli")
+
+
+def python_version() -> str:
+    return platform.python_version()
+
+
+def host_os() -> str:
+    return platform.system().lower()  # 'linux', 'darwin', 'windows'
+
+
+def host_env() -> str:
+    return "docker" if os.environ.get("RUNS_IN_DOCKER") else "native"
+
+
+def platform_info() -> str:
+    return f"python {python_version()}; {host_os()}; {host_env()}"
+
+
+def _pypi_latest(
+    project: str, *, include_prereleases: bool, timeout: float = 2.5, user_agent: str | None = None
+) -> tuple[str | None, str | None]:
+    """Return (latest_version, project_url) from PyPI, skipping yanked files."""
+    url = f"https://pypi.org/pypi/{project}/json"
+    headers = {"Accept": "application/json"}
+    if user_agent:
+        headers["User-Agent"] = user_agent
+    req = urllib.request.Request(url, headers=headers)
+
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            data = json.load(resp)
+    except Exception:
+        return None, None  # network/404/etc.
+
+    releases = data.get("releases") or {}
+    candidates: list[Version] = []
+    for s, files in releases.items():
+        try:
+            v = Version(s)
+        except InvalidVersion:
+            continue
+        the_files = files or []
+        if any(f.get("yanked", False) for f in the_files):
+            continue
+        if (v.is_prerelease or v.is_devrelease) and not include_prereleases:
+            continue
+        candidates.append(v)
+
+    if not candidates:
+        return None, None
+
+    latest = str(max(candidates))
+    info = data.get("info") or {}
+    proj_url = info.get("project_url") or info.get("package_url") or f"https://pypi.org/project/{project}/"
+    return latest, proj_url
+
+
+def _installed_version(distribution_name: str, fallback: str | None = None) -> str | None:
+    try:
+        return importlib_metadata.version(distribution_name)
+    except importlib_metadata.PackageNotFoundError:
+        return fallback
+
+
+def check_for_update(settings: Settings) -> None:
+    # Make it possible to disable update check, i.e in CI
+    if os.environ.get("PYTHON_DISABLE_UPDATE_CHECK"):
+        return
+
+    # Check if we are allowed to perform an update check
+    if not settings.should_perform_update_check():
+        return
+
+    # Determine current version
+    project = "remotivelabs-cli"
+    cur = cli_version() or _installed_version(project)
+    if not cur:
+        return  # unknown version → skip silently
+
+    # We end up here if last_update_check_time is None or should_perform_update_check is true
+    include_prereleases = Version(cur).is_prerelease or Version(cur).is_devrelease
+
+    latest, proj_url = _pypi_latest(
+        project, include_prereleases=include_prereleases, user_agent=f"{project}/{cur} (+https://pypi.org/project/{project}/)"
+    )
+    if latest:
+        if Version(latest) > Version(cur):
+            _print_update_info(
+                cur,
+                latest,
+            )
+    settings.set_last_update_check_time(datetime.datetime.now().isoformat())
+
+
+def _print_update_info(cur: str, latest: str) -> None:
+    instructions = (
+        "upgrade with: docker pull remotivelabs/remotivelabs-cli"
+        if os.environ.get("RUNS_IN_DOCKER")
+        else "upgrade with: pipx upgrade remotivelabs-cli"
+    )
+
+    print_hint(f"Update available: remotivelabs-cli {cur} → {latest} , ({instructions}) we always recommend to use latest version")

remotivelabs_cli-0.5.0a1.dist-info/METADATA

@@ -0,0 +1,51 @@
+Metadata-Version: 2.4
+Name: remotivelabs-cli
+Version: 0.5.0a1
+Summary: CLI for operating RemotiveCloud and RemotiveBroker
+Keywords: automotive,autotech,networking,CAN
+Author: Remotivelabs
+Author-email: Remotivelabs <support@remotivelabs.com>
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Manufacturing
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: Other/Proprietary License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Communications
+Classifier: Topic :: Internet
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Requires-Dist: trogon>=0.5.0
+Requires-Dist: typer==0.12.5
+Requires-Dist: click<8.2.0
+Requires-Dist: remotivelabs-broker~=0.11.1
+Requires-Dist: rich~=13.7.0
+Requires-Dist: pyjwt~=2.6
+Requires-Dist: zeroconf~=0.127.0
+Requires-Dist: websocket-client~=1.6
+Requires-Dist: plotext~=5.2
+Requires-Dist: python-socketio>=4.6.1
+Requires-Dist: python-can>=4.3.1
+Requires-Dist: grpc-stubs>=1.53.0.5
+Requires-Dist: mypy-protobuf>=3.0.0
+Requires-Dist: types-requests~=2.32.0.20240622
+Requires-Dist: pydantic~=2.12.4
+Requires-Dist: email-validator~=2.2.0
+Requires-Dist: requests~=2.32.4
+Requires-Dist: semver>=3.0.4
+Requires-Python: >=3.10, <4.0
+Description-Content-Type: text/markdown
+
+# RemotiveLabs - CLI
+[![PyPI - Version](https://img.shields.io/pypi/v/remotivelabs-cli.svg)](https://pypi.org/project/remotivelabs-cli)
+
+Use this CLI with our cloud and broker as a compliment to code and web tools.
+
+Read more at https://docs.remotivelabs.com/docs/remotive-cli
+