kleinkram 0.37.0.dev20241113182530__py3-none-any.whl → 0.37.0.dev20241118070559__py3-none-any.whl

kleinkram/auth/auth.py

@@ -1,160 +0,0 @@
-import json
-import os
-import urllib.parse
-import webbrowser
-from http.server import BaseHTTPRequestHandler, HTTPServer
-from pathlib import Path
-from typing_extensions import Optional
-
-import typer
-from typing_extensions import Annotated
-
-from kleinkram.consts import API_URL
-
-TOKEN_FILE = Path(os.path.expanduser("~/.kleinkram.json"))
-REFRESH_TOKEN = "refreshtoken"
-AUTH_TOKEN = "authtoken"
-CLI_KEY = "clikey"
-
-
-class TokenFile:
-    def __init__(self):
-        try:
-            with TOKEN_FILE.open("r") as token_file:
-                content = json.load(token_file)
-                self.endpoint = content["endpoint"]
-                self.tokens = content["tokens"]
-        except FileNotFoundError:
-            self.tokens = {}
-            self.endpoint = API_URL
-        except json.JSONDecodeError:
-            print("Token file is corrupted. Please run 'login' command again.")
-            raise
-
-    def isCliToken(self):
-        return CLI_KEY in self.tokens[self.endpoint]
-
-    def getAuthToken(self):
-        return self.tokens[self.endpoint][AUTH_TOKEN]
-
-    def getRefreshToken(self):
-        return self.tokens[self.endpoint][REFRESH_TOKEN]
-
-    def getCLIToken(self):
-        return self.tokens[self.endpoint][CLI_KEY]
-
-    def writeToFile(self):
-        res = {
-            "endpoint": self.endpoint,
-            "tokens": self.tokens,
-        }
-        with TOKEN_FILE.open("w") as token_file:
-            json.dump(res, token_file)
-
-    def saveTokens(self, tokens):
-        self.tokens[self.endpoint] = tokens
-        self.writeToFile()
-
-
-class OAuthCallbackHandler(BaseHTTPRequestHandler):
-    def do_GET(self):
-        if self.path.startswith("/cli/callback"):
-            query = urllib.parse.urlparse(self.path).query
-            params = urllib.parse.parse_qs(query)
-            self.server.tokens = {
-                AUTH_TOKEN: params.get(AUTH_TOKEN)[0],
-                REFRESH_TOKEN: params.get(REFRESH_TOKEN)[0],
-            }
-            self.send_response(200)
-            self.send_header("Content-type", "text/html")
-            self.end_headers()
-            self.wfile.write(b"Authentication successful. You can close this window.")
-            return
-        print("here")
-
-    def log_message(self, format, *args):
-        pass
-
-
-def get_auth_tokens():
-    server_address = ("", 8000)
-    httpd = HTTPServer(server_address, OAuthCallbackHandler)
-    httpd.handle_request()
-    return httpd.tokens
-
-
-def logout():
-    """
-    Logout from the currently set endpoint.
-    """
-    tokenfile = TokenFile()
-    tokenfile.tokens[tokenfile.endpoint] = {}
-    tokenfile.writeToFile()
-    print("Logged out.")
-
-
-def login(
-    key: Optional[str] = typer.Option(None, help="CLI Key", hidden=True),
-    open_browser: Optional[bool] = typer.Option(
-        True, help="Open browser for authentication"
-    ),
-):
-    """
-    Login into the currently set endpoint.\n
-    By default, it will open the browser for authentication. On machines without a browser, you can manually open the URL provided and paste the tokens back.
-    """
-    tokenfile = TokenFile()
-    if key:
-        token = {}
-        token[CLI_KEY] = key
-        tokenfile.saveTokens(token)
-
-    else:
-        url = tokenfile.endpoint + "/auth/google?state=cli"
-
-        has_browser = True
-        try:
-            browser_available = webbrowser.get()
-            if not browser_available:
-                raise Exception("No web browser available.")
-        except Exception as e:
-            has_browser = False
-
-        if has_browser and open_browser:
-            webbrowser.open(url)
-            auth_tokens = get_auth_tokens()
-
-            if not auth_tokens:
-                raise Exception("Failed to get authentication tokens.")
-
-            tokenfile.saveTokens(auth_tokens)
-            print("Authentication complete. Tokens saved to ~/.kleinkram.json.")
-            return
-
-        print(
-            f"Please open the following URL manually in your browser to authenticate: {url + '-no-redirect'}"
-        )
-        print("Enter the authentication token provided after logging in:")
-        manual_auth_token = input("Authentication Token: ")
-        manual_refresh_token = input("Refresh Token: ")
-        if manual_auth_token:
-            tokenfile.saveTokens(
-                {AUTH_TOKEN: manual_auth_token, REFRESH_TOKEN: manual_refresh_token}
-            )
-            print("Authentication complete. Tokens saved to tokens.json.")
-        else:
-            raise ValueError("Failed to get authentication tokens.")
-
-
-def setCliKey(key: Annotated[str, typer.Argument(help="CLI Key")]):
-    """
-    Set the CLI key (Actions Only)
-
-    Same as login with the --key option.
-    Should never be used by the user, only in docker containers launched from within Kleinkram.
-    """
-    tokenfile = TokenFile()
-    if not tokenfile.endpoint in tokenfile.tokens:
-        tokenfile.tokens[tokenfile.endpoint] = {}
-    tokenfile.tokens[tokenfile.endpoint][CLI_KEY] = key
-    tokenfile.writeToFile()

kleinkram/endpoint/endpoint.py

@@ -1,58 +0,0 @@
-import typer
-
-from kleinkram.auth.auth import TokenFile
-
-endpoint = typer.Typer(
-    name="endpoint",
-    help="Get Or Set the current endpoint.\n\nThe endpoint is used to determine the API server to connect to"
-    "(default is the API server of https://datasets.leggedrobotics.com).",
-    no_args_is_help=True,
-    context_settings={"help_option_names": ["-h", "--help"]},
-)
-
-
-@endpoint.command("set")
-def set_endpoint(endpoint: str = typer.Argument(None, help="API endpoint to use")):
-    """
-    Set the current endpoint
-
-    Use this command to switch between different API endpoints.\n
-    Standard endpoints are:\n
-    - http://localhost:3000\n
-    - https://api.datasets.leggedrobotics.com\n
-    - https://api.datasets.dev.leggedrobotics.com
-    """
-
-    if not endpoint:
-        raise ValueError("No endpoint provided.")
-
-    tokenfile = TokenFile()
-    tokenfile.endpoint = endpoint
-    tokenfile.writeToFile()
-
-    print()
-    print("Endpoint set to: " + endpoint)
-    if tokenfile.endpoint not in tokenfile.tokens:
-        print(
-            "Not authenticated on this endpoint, please execute 'klein login' to authenticate."
-        )
-
-
-@endpoint.command("get")
-def get_endpoints():
-    """
-    Get the current endpoint
-
-    Also displays all endpoints with saved tokens.
-    """
-    tokenfile = TokenFile()
-    print("Current: " + tokenfile.endpoint)
-    print()
-
-    if not tokenfile.tokens:
-        print("No saved tokens found.")
-        return
-
-    print("Saved Tokens found for:")
-    for _endpoint, _ in tokenfile.tokens.items():
-        print("- " + _endpoint)

kleinkram/error_handling.py

@@ -1,177 +0,0 @@
-import sys
-import typing
-
-import typer
-from httpx import HTTPStatusError, ReadError, RemoteProtocolError
-from rich.console import Console
-from rich.panel import Panel
-from typer import Typer
-
-from kleinkram.api_client import NotAuthenticatedException
-
-ExceptionType = "typing.Type[Exception]"
-ErrorHandlingCallback = typing.Callable[[Exception], int]
-
-
-class AbortException(Exception):
-
-    def __init__(self, message: str):
-        self.message = message
-
-
-class AccessDeniedException(Exception):
-
-    def __init__(self, message: str, api_error: str):
-        self.message = message
-        self.api_error = api_error
-
-
-def not_yet_implemented_handler(e: Exception):
-    console = Console(file=sys.stderr)
-    default_msg = "This feature is not yet implemented. Please check for updates or use the web interface."
-    panel = Panel(
-        f"{default_msg}",
-        title="Not Yet Implemented",
-        style="yellow",
-        padding=(1, 2),
-        highlight=True,
-    )
-    print()
-    console.print(panel)
-    print()
-
-
-def not_authenticated_handler(e: NotAuthenticatedException):
-    console = Console(file=sys.stderr)
-    panel = Panel(
-        f"{e.message}\n » Please run 'klein login' to authenticate.",
-        title="Not Authenticated",
-        style="yellow",
-        padding=(1, 2),
-        highlight=True,
-    )
-    print()
-    console.print(panel)
-    print()
-
-
-def access_denied_handler(e: AccessDeniedException):
-    console = Console(file=sys.stderr)
-    panel = Panel(
-        f"{e.message}\n » API Response: {e.api_error}",
-        title="Access Denied",
-        style="red",
-        padding=(1, 2),
-        highlight=True,
-    )
-    print()
-    console.print(panel)
-    print()
-
-
-def value_error_handler(e: Exception):
-    console = Console(file=sys.stderr)
-    panel = Panel(
-        str(e),
-        title="Invalid Argument",
-        style="red",
-        padding=(1, 2),
-        highlight=True,
-    )
-    print()
-    console.print(panel)
-    print()
-
-
-def http_status_error_handler(e: HTTPStatusError):
-    console = Console(file=sys.stderr)
-    panel = Panel(
-        f"An HTTP error occurred: {e}\n\n » Please report this error to the developers.",
-        title="HTTP Status Error",
-        style="red",
-        padding=(1, 2),
-        highlight=True,
-    )
-    print()
-    console.print(panel)
-    print()
-
-
-def remote_down_handler(e: Exception):
-    console = Console(file=sys.stderr)
-    panel = Panel(
-        f"An error occurred while communicating with the remote server: {e}\n"
-        f"\n » The server may be down or unreachable; please try again.",
-        title="Remote Protocol Error",
-        style="yellow",
-        padding=(1, 2),
-        highlight=True,
-    )
-    print()
-    console.print(panel)
-    print()
-
-
-def abort_handler(e: AbortException):
-    console = Console(file=sys.stderr)
-    panel = Panel(
-        f"{e.message}",
-        title="Command Aborted",
-        style="yellow",
-        padding=(1, 2),
-        highlight=True,
-    )
-    print()
-    console.print(panel)
-    print()
-
-
-class ErrorHandledTyper(Typer):
-    error_handlers: typing.Dict[ExceptionType, ErrorHandlingCallback] = {
-        NotAuthenticatedException: not_authenticated_handler,
-        AccessDeniedException: access_denied_handler,
-        HTTPStatusError: http_status_error_handler,
-        NotImplementedError: not_yet_implemented_handler,
-        ValueError: value_error_handler,
-        RemoteProtocolError: remote_down_handler,
-        ReadError: remote_down_handler,
-        AbortException: abort_handler,
-    }
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-
-    def error_handler(self, exc: ExceptionType):
-        def decorator(f: ErrorHandlingCallback):
-            self.error_handlers[exc] = f
-            return f
-
-        return decorator
-
-    def __call__(self, *args, **kwargs):
-        try:
-            super(ErrorHandledTyper, self).__call__(*args, **kwargs)
-
-        except Exception as e:
-
-            # exit with error code 1 if no error handler is defined
-            if type(e) not in self.error_handlers:
-                typer.secho(
-                    f"An unhanded error of type {type(e).__name__} occurred.",
-                    fg=typer.colors.RED,
-                )
-
-                typer.secho(
-                    " » Please report this error to the developers.",
-                    fg=typer.colors.RED,
-                )
-
-                typer.secho(f"\n\n{e}:", fg=typer.colors.RED)
-                console = Console()
-                console.print_exception(show_locals=True)
-
-            else:
-                self.error_handlers[type(e)](e)
-
-            # exit with error code 1
-            exit(1)

kleinkram/file/file.py

@@ -1,144 +0,0 @@
-import os
-from typing_extensions import Optional, Annotated, List
-
-import httpx
-import requests
-import typer
-
-from kleinkram.api_client import AuthenticatedClient
-from kleinkram.error_handling import AccessDeniedException
-
-file = typer.Typer(
-    name="file",
-    help="File operations",
-    no_args_is_help=True,
-    context_settings={"help_option_names": ["-h", "--help"]},
-)
-
-
-@file.command("download")
-def download_file(
-    file_uuid: Annotated[List[str], typer.Option(help="UUIDs of the files")],
-    local_path: Annotated[
-        str,
-        typer.Option(
-            prompt=True,
-            help="Local path to save the file",
-        ),
-    ],
-):
-    """
-    Download files by UUIDs to a local path.\n
-    Examples:\n
-    klein file download --file-uuid="9d5a9..."  --file-uuid="9833f..." --local-path="~/Downloads" \n
-    klein file download --file-uuid="9d5a9..."  --local-path="~/Downloads/example.bag"
-
-    """
-    client = AuthenticatedClient()
-    url = f"/file/download"
-
-    fixed_local_path = os.path.expanduser(local_path)
-
-    isDir = os.path.isdir(fixed_local_path)
-    chunk_size = 1024 * 100  # 100 KB chunks, adjust size if needed
-
-    for file in file_uuid:
-        response = client.get(
-            url,
-            params={"uuid": file, "expires": True},
-        )
-        if response.status_code >= 400:
-            raise AccessDeniedException(
-                f"Failed to download file: {response.json()['message']}",
-                "Status Code: " + str(response.status_code),
-            )
-        download_url = response.text
-        if isDir:
-            filename = download_url.split("/")[6].split("?")[0]  # Trust me bro
-            filepath = os.path.join(fixed_local_path, filename)
-        elif not isDir and len(file_uuid) == 1:
-            filepath = fixed_local_path
-        else:
-            raise ValueError("Multiple files can only be downloaded to a directory")
-        if os.path.exists(filepath):
-            raise FileExistsError(f"File already exists: {filepath}")
-        print(f"Downloading to: {filepath}")
-        filestream = requests.get(download_url, stream=True)
-        with open(filepath, "wb") as f:
-            for chunk in filestream.iter_content(chunk_size=chunk_size):
-                if chunk:  # Filter out keep-alive new chunks
-                    f.write(chunk)
-            print(f"Completed")
-
-
-@file.command("list")
-def list_files(
-    project: Optional[str] = typer.Option(None, help="Name of Project"),
-    mission: Optional[str] = typer.Option(None, help="Name of Mission"),
-    topics: Optional[str] = typer.Option(None, help="Comma separated list of topics"),
-    tags: Optional[str] = typer.Option(
-        None, help="Comma separated list of tagtype:tagvalue pairs"
-    ),
-):
-    """
-    List all files with optional filters for project, mission, or topics.
-
-    Can list files of a project, mission, or with specific topics (Logical AND).
-    Examples:\n
-        - 'klein filelist'\n
-        - 'klein file list --project "Project_1"'\n
-        - 'klein file list --mission "Mission_1"'\n
-        - 'klein file list --topics "/elevation_mapping/semantic_map,/elevation_mapping/elevation_map_raw"'\n
-        - 'klein file list --topics "/elevation_mapping/semantic_map,/elevation_mapping/elevation_map_raw" --mission "Mission A"'
-    """
-    try:
-        url = f"/file/filteredByNames"
-        params = {}
-        if project:
-            params["projectName"] = project
-        if mission:
-            params["missionName"] = mission
-        if topics:
-            params["topics"] = topics
-        if tags:
-            params["tags"] = {}
-            for tag in tags.split(","):
-                tagtype, tagvalue = tag.split("§")
-                params["tags"][tagtype] = tagvalue
-
-        client = AuthenticatedClient()
-        response = client.get(
-            url,
-            params=params,
-        )
-        if response.status_code >= 400:
-            raise AccessDeniedException(
-                f"Failed to fetch files: {response.json()['message']} ({response.status_code})",
-                "Access Denied",
-            )
-        data = response.json()
-        missions_by_project_uuid = {}
-        files_by_mission_uuid = {}
-        for file in data:
-            mission_uuid = file["mission"]["uuid"]
-            project_uuid = file["mission"]["project"]["uuid"]
-            if project_uuid not in missions_by_project_uuid:
-                missions_by_project_uuid[project_uuid] = []
-            if mission_uuid not in missions_by_project_uuid[project_uuid]:
-                missions_by_project_uuid[project_uuid].append(mission_uuid)
-            if mission_uuid not in files_by_mission_uuid:
-                files_by_mission_uuid[mission_uuid] = []
-            files_by_mission_uuid[mission_uuid].append(file)
-
-        print("Files by mission & Project:")
-        for project_uuid, missions in missions_by_project_uuid.items():
-            first_file = files_by_mission_uuid[missions[0]][0]
-            print(f"* {first_file['mission']['project']['name']}")
-            for mission in missions:
-                print(f"  - {files_by_mission_uuid[mission][0]['mission']['name']}")
-                for file in files_by_mission_uuid[mission]:
-                    print(f"    - '{file['filename']}'")
-
-    except httpx.HTTPError as e:
-        print(f"Failed to fetch missions: {e}")
-        raise e