kaas-cli 0.1.1__tar.gz

kaas_cli-0.1.1/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2024 Runtimeverification, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files KaaS (K as a Service), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

kaas_cli-0.1.1/PKG-INFO

@@ -0,0 +1,69 @@
+Metadata-Version: 2.1
+Name: kaas-cli
+Version: 0.1.1
+Summary: Command line utility for K as a Service
+Author: Runtime Verification, Inc.
+Author-email: contact@runtimeverification.com
+Requires-Python: >=3.10,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: gql[requests] (>=3.4.0,<4.0.0)
+Requires-Dist: hurry-filesize (>=0.9,<0.10)
+Requires-Dist: jmespath (>=1.0.1,<2.0.0)
+Requires-Dist: pytest (>=8.0.1,<9.0.0)
+Requires-Dist: pytest-watch (>=4.2.0,<5.0.0)
+Requires-Dist: python-dotenv (>=1.0.1,<2.0.0)
+Requires-Dist: requests (>=2.31.0,<3.0.0)
+Requires-Dist: types-jmespath (>=1.0.2.20240106,<2.0.0.0)
+Requires-Dist: urllib3 (>=2.1.0,<3.0.0)
+Description-Content-Type: text/markdown
+
+# KaaS CLI
+
+## For Developers
+
+Prerequisites: `python >= 3.10`, `pip >= 20.0.2`, `poetry >= 1.3.2`.
+
+### Installation
+
+To install the package using `pip`, start by building it:
+
+```bash
+make build
+pip install dist/*.whl
+```
+
+Configure the CLI by copying the example environment file and setting up the necessary environment variables:
+
+```bash
+cp .flaskenv.example .flaskenv
+```
+
+Then, edit the `.flaskenv` file to match your settings.
+
+### Environment Variables
+
+Here's an overview of the environment variables:
+
+- **SERVER_URL**: The KaaS server API address for the main interaction within the CLI tool. This is a required field. For local development, use `http://localhost:5000`.
+- **DEFAULT_DIRECTORY**: The folder path for artifacts. This is an optional field. You can leave it empty.
+- **DEFAULT_PROJECT_ID**: Artifacts should be associated with a project ID. This is an optional field. You can leave it empty.
+- **DEFAULT_TOKEN**: If the user is not the owner of the project, they are required to provide a security token. This is an optional field. You can leave it empty.
+
+### Usage
+
+After installing the dependencies with `poetry install`, you can spawn a shell using `poetry shell`, or alternatively, use `make`:
+
+```bash
+make shell
+kaas-cli hello
+```
+
+To verify the installation, run `kaas-cli hello`. If you see the message `Hello World!`, the CLI is set up correctly.
+
+### Documentation
+
+For detailed usage instructions of the `kaas-cli` tool, please refer to the official [documentation](https://docs.runtimeverification.com/kaas/guides/getting-started).
+

kaas_cli-0.1.1/README.md

@@ -0,0 +1,46 @@
+# KaaS CLI
+
+## For Developers
+
+Prerequisites: `python >= 3.10`, `pip >= 20.0.2`, `poetry >= 1.3.2`.
+
+### Installation
+
+To install the package using `pip`, start by building it:
+
+```bash
+make build
+pip install dist/*.whl
+```
+
+Configure the CLI by copying the example environment file and setting up the necessary environment variables:
+
+```bash
+cp .flaskenv.example .flaskenv
+```
+
+Then, edit the `.flaskenv` file to match your settings.
+
+### Environment Variables
+
+Here's an overview of the environment variables:
+
+- **SERVER_URL**: The KaaS server API address for the main interaction within the CLI tool. This is a required field. For local development, use `http://localhost:5000`.
+- **DEFAULT_DIRECTORY**: The folder path for artifacts. This is an optional field. You can leave it empty.
+- **DEFAULT_PROJECT_ID**: Artifacts should be associated with a project ID. This is an optional field. You can leave it empty.
+- **DEFAULT_TOKEN**: If the user is not the owner of the project, they are required to provide a security token. This is an optional field. You can leave it empty.
+
+### Usage
+
+After installing the dependencies with `poetry install`, you can spawn a shell using `poetry shell`, or alternatively, use `make`:
+
+```bash
+make shell
+kaas-cli hello
+```
+
+To verify the installation, run `kaas-cli hello`. If you see the message `Hello World!`, the CLI is set up correctly.
+
+### Documentation
+
+For detailed usage instructions of the `kaas-cli` tool, please refer to the official [documentation](https://docs.runtimeverification.com/kaas/guides/getting-started).

kaas_cli-0.1.1/pyproject.toml

@@ -0,0 +1,78 @@
+[project.urls]
+Homepage = "https://github.com/runtimeverification/kaas"
+Issues = "https://github.com/runtimeverification/kaas"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.poetry]
+name = "kaas-cli"
+version = "0.1.1"
+description = "Command line utility for K as a Service"
+authors = [
+    "Runtime Verification, Inc. <contact@runtimeverification.com>",
+]
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.10"
+gql = { version = "^3.4.0", extras = [ "requests" ] }
+urllib3 = "^2.1.0"
+hurry-filesize = "^0.9"
+pytest-watch = "^4.2.0"
+python-dotenv = "^1.0.1"
+pytest = "^8.0.1"
+jmespath = "^1.0.1"
+types-jmespath = "^1.0.2.20240106"
+requests = "^2.31.0"
+
+[tool.poetry.group.dev.dependencies]
+autoflake = "*"
+black = "*"
+flake8 = "*"
+flake8-bugbear = "*"
+flake8-comprehensions = "*"
+flake8-quotes = "*"
+flake8-type-checking = "*"
+isort = "*"
+mypy = "*"
+pep8-naming = "*"
+pytest = "*"
+pytest-cov = "*"
+pytest-mock = "*"
+pytest-xdist = "*"
+pyupgrade = "*"
+typer = "*"
+types-requests = "*"
+
+[tool.poetry.scripts]
+kaas-cli = "kaas_cli.__main__:main"
+
+[tool.isort]
+profile = "black"
+line_length = 120
+
+[tool.autoflake]
+recursive = true
+expand-star-imports = true
+remove-all-unused-imports = true
+ignore-init-module-imports = true
+remove-duplicate-keys = true
+remove-unused-variables = true
+
+[tool.black]
+line-length = 120
+skip-string-normalization = true
+
+[tool.mypy]
+disallow_untyped_defs = true
+
+
+[[tool.mypy.overrides]]
+module = "hurry.*"
+ignore_missing_imports = true
+
+[[tool.mypy.overrides]]
+module = "dotenv.*"
+ignore_missing_imports = true

kaas_cli-0.1.1/src/kaas_cli/__init__.py

@@ -0,0 +1,2 @@
+__app_name__ = 'kaas-cli'
+__version__ = '0.1.2'

kaas_cli-0.1.1/src/kaas_cli/__main__.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+import click
+
+from .cli import cli  # Import the Click group you've defined
+from .config import CustomHelpOption
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+
+def register_command_aliases() -> None:
+    # Collect aliases and their corresponding commands in a list
+    aliases_to_register = []
+    for _command_name, command in cli.commands.items():
+        if isinstance(command, CustomHelpOption):
+            # Ensure command.callback is not None before proceeding
+            if command.callback is not None:
+                for alias in command.aliases:
+                    # Avoid adding an alias if it's already a command
+                    if alias not in cli.commands:
+                        # Add type assertion to ensure command.callback is not None
+                        callback: Callable[..., Any] = command.callback
+                        aliases_to_register.append((alias, callback))
+
+    # Register collected aliases as commands
+    for alias, callback in aliases_to_register:
+        cli.command(name=alias, cls=click.Command)(callback)
+
+
+def main() -> None:
+    register_command_aliases()
+    cli()
+
+
+if __name__ == "__main__":
+    main()

kaas_cli-0.1.1/src/kaas_cli/cli.py

@@ -0,0 +1,205 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import click
+
+from .client import KaasClient
+from .config import DEFAULT_DIRECTORY, DEFAULT_PROJECT_ID, DEFAULT_TOKEN, SERVER_URL, CustomHelpOption
+
+if TYPE_CHECKING:
+    from click.core import Context
+
+
+@click.group()
+@click.option("--url", "-u", default=SERVER_URL, show_default=True, help="Server URL")
+@click.option("--token", "-t", default=DEFAULT_TOKEN, help="Personal access token for vault")
+@click.option("--vault", "-v", default=DEFAULT_PROJECT_ID, help="Vault hash")
+@click.pass_context
+def cli(ctx: Context, url: str, token: str | None, vault: str | None) -> None:
+    """KaaS Command Line Interface"""
+    ctx.ensure_object(dict)
+    ctx.obj["client"] = KaasClient(url=url, token=token, vault=vault)
+
+
+@cli.command(cls=CustomHelpOption, help="Upload proofs to the remote server.")
+@click.option(
+    "-d",
+    "--directory",
+    default=DEFAULT_DIRECTORY,
+    show_default=True,
+    type=click.Path(exists=True, file_okay=False, dir_okay=True),
+    help="Directory containing proofs to upload",
+)
+@click.option("--url", "-u", default=SERVER_URL, show_default=True, help="Server URL")
+@click.option("--token", "-t", default=DEFAULT_TOKEN, help="Personal access token for vault")
+@click.option("--vault", "-v", default=DEFAULT_PROJECT_ID, help="Vault hash")
+@click.pass_context
+def upload(ctx: Context, directory: str, url: str | None, token: str | None, vault: str | None) -> None:
+    ctx.ensure_object(dict)
+    client: KaasClient = KaasClient(url=url, token=token, vault=vault)
+    ctx.obj["client"] = client
+    response_message = client.upload_files_s3(directory=directory)
+    click.echo(response_message)
+
+
+@cli.command(cls=CustomHelpOption, help="Download proofs from the remote server.")
+@click.option(
+    "-d",
+    "--directory",
+    default=DEFAULT_DIRECTORY,
+    show_default=True,
+    type=click.Path(exists=False, file_okay=False, dir_okay=True),
+    help="Directory to save downloaded proofs",
+)
+@click.option("--url", "-u", default=SERVER_URL, show_default=True, help="Server URL")
+@click.option("--token", "-t", default=DEFAULT_TOKEN, help="Personal access token for vault")
+@click.option("--vault", "-v", default=DEFAULT_PROJECT_ID, help="Vault hash")
+@click.argument("version_address", required=False)
+@click.pass_context
+def download(
+        ctx: Context,
+        version_address: str | None,
+        directory: str, url: str | None, token: str | None, vault: str | None
+) -> None:  # type: ignore
+    ctx.ensure_object(dict)
+    client: KaasClient = KaasClient(url=url, token=token, vault=vault)
+    ctx.obj["client"] = client
+    if not version_address:
+        message = client.download_last_version(target_directory=directory)
+        if message:
+            click.echo(message)
+        return
+
+    message = client.download_version(version_address, target_directory=directory)
+    if message:
+        click.echo(message)
+
+
+@cli.command(cls=CustomHelpOption, help="Say hello.")
+@click.option("-n", "--name", default="World", show_default=True, help="Name to say hello to")
+@click.pass_context
+def hello(ctx: Context, name: str) -> None:
+    client: KaasClient = ctx.obj["client"]
+
+    response = client.hello(name=name)
+    click.echo(response)
+
+
+@cli.command(cls=CustomHelpOption, help="Login to the system.")
+@click.pass_context
+def login(ctx: Context) -> None:
+    client: KaasClient = ctx.obj["client"]
+    data = client.login()
+    click.echo(f"Your user code: {data.user_code}")
+    click.echo(f"Open the link and type your code {data.verification_uri}")
+    click.echo("Then hit 'enter'")
+    input_value = click.prompt("Press Enter to continue or type 'q' to quit", default="", show_default=False)
+    if input_value.lower() == 'q':
+        click.echo("You left authentication")
+        return
+    click.echo("You pressed Enter. The application continues...")
+    confirm_success = client.confirm_login(data.device_code).success
+    if not confirm_success:
+        click.echo("Authentication failed")
+        return
+    click.echo("Access token received. We store it in cache folder")
+
+
+@cli.command(cls=CustomHelpOption, help="List local proofs.", aliases=['l', 'ls'])
+@click.option(
+    "-d",
+    "--directory",
+    default=DEFAULT_DIRECTORY,
+    show_default=True,
+    type=click.Path(exists=True, file_okay=False, dir_okay=True),
+    help="Directory to list local proofs",
+)
+@click.option("--remote", is_flag=True, help="List remote proofs instead of local proofs", default=False)
+@click.pass_context
+def list(ctx: Context, directory: str = DEFAULT_DIRECTORY, remote: bool = False) -> None:
+    client: KaasClient = ctx.obj["client"]
+    if remote:
+        proofs = client.list_remote()
+    else:
+        proofs = client.list_local_proofs(directory=directory)
+    if not proofs:
+        click.echo('No proofs found')
+    for proof in proofs:
+        click.echo(proof)
+
+
+def list_remote(ctx: Context) -> None:
+    client: KaasClient = ctx.obj["client"]
+    proofs = client.list_remote()
+    for proof in proofs:
+        click.echo(proof)
+
+
+@cli.command(cls=CustomHelpOption, name="check-auth", help="Check authentication status.")
+@click.pass_context
+def check_auth(ctx: Context) -> None:
+    client: KaasClient = ctx.obj["client"]
+    is_authenticated = client.check()
+    if is_authenticated:
+        click.echo("You are currently authenticated.")
+    else:
+        click.echo("You are not authenticated. Please log in.")
+
+
+@cli.command(cls=CustomHelpOption, name="list-vaults", help="List remote vaults owned by your KaaS account.")
+@click.pass_context
+def list_vaults(ctx: Context) -> None:
+    client: KaasClient = ctx.obj["client"]
+    vaults = client.list_vaults()
+
+    if not vaults:
+        click.echo("No vaults")
+        return
+
+    for vault in vaults:
+        click.echo(vault)
+
+
+@cli.command(cls=CustomHelpOption, name="list-keys", help="List remote keys owned by <VAULT_ADDRESS>")
+@click.argument("vault_address", required=True)
+@click.pass_context
+def list_keys(ctx: Context, vault_address: str) -> None:
+    client: KaasClient = ctx.obj["client"]
+    keys = client.list_keys(vault_address)
+
+    if not keys:
+        click.echo(f"No keys found for vault {vault_address}")
+        return
+
+    click.echo(f"Keys for vault {vault_address}:")
+    for key in keys:
+        click.echo(key)
+
+
+@cli.command(cls=CustomHelpOption, name="list-versions",
+             help="List remote versions of a cached artifact, with <VAULT_ADDRESS> as the address of the vault.")
+@click.argument("vault_address", required=True)
+@click.pass_context
+def list_versions(ctx: Context, vault_address: str) -> None:
+    client: KaasClient = ctx.obj["client"]
+    versions = client.list_versions(vault_address)
+
+    if not versions:
+        click.echo(f"No versions found for vault {vault_address}")
+        return
+
+    click.echo(f"Versions for vault {vault_address}:")
+    for version in versions:
+        click.echo(version)
+
+
+@cli.command(cls=CustomHelpOption, name="logout", help="Log out from the system.")
+@click.pass_context
+def logout(ctx: Context) -> None:
+    client: KaasClient = ctx.obj["client"]
+    logout_success = client.logout()
+    if logout_success:
+        click.echo("You have been logged out successfully.")
+    else:
+        click.echo("Logout failed. You may not be logged in.")

kaas_cli-0.1.1/src/kaas_cli/client.py

@@ -0,0 +1,617 @@
+from __future__ import annotations
+
+import json
+import logging
+import os
+import pickle
+import shutil
+import tempfile
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Final, List
+from uuid import uuid4
+from zipfile import ZipFile
+
+import click
+import jmespath
+import requests
+from gql import Client, gql
+from gql.transport.requests import RequestsHTTPTransport
+from hurry.filesize import size
+from requests import JSONDecodeError, Session
+
+from kaas_cli.types import KaasCliException
+
+if TYPE_CHECKING:
+    from .types import File_Data, Metadata
+
+from .constants import (
+    CONFIG_LOG_PATH,
+    CONFIG_SESSION_PATH,
+    DEVICE_LOGIN_URL,
+    FILES_LIST_URL,
+    FILES_URL,
+    GRAPHQL_URL,
+    UPLOAD_FAILURE_MESSAGE,
+    UPLOAD_SUCCESS_MESSAGE,
+    USER_URL,
+    VAULTS_KEY_URL,
+    VAULTS_ROOT_URL,
+)
+
+
+@dataclass(frozen=True)
+class DeviceAuth:
+    device_code: str
+    expires_in: int
+    interval: int
+    user_code: str
+    verification_uri: str
+
+
+@dataclass(frozen=True)
+class Confirmation:
+    success: bool
+
+
+class CustomSession(Session):
+    def get(self, *args: Any, **kwargs: Any) -> Any:
+        response = super().get(*args, **kwargs)
+        try:
+            json_response = response.json()
+            if 'error' in json_response:
+                raise ValueError(json_response['error'], json_response.get('message', 'No message provided'))
+            return json_response
+        except JSONDecodeError as e:
+            logging.error(f"GET request JSON decode failed: {e}")
+            raise e
+        except ValueError as e:
+            logging.error(f"GET request failed: {e}")
+            click.echo(f"GET request failed: {e}")
+            raise e
+
+    def post(self, *args: Any, **kwargs: Any) -> Any:
+        response = super().post(*args, **kwargs)
+        try:
+            json_response = response.json()
+            if 'error' in json_response:
+                raise ValueError(json_response['error'], json_response.get('message', 'No message provided'))
+            return json_response
+        except JSONDecodeError as e:
+            logging.error(f"POST request JSON decode failed: {e}")
+            raise e
+        except ValueError as e:
+            logging.error(f"POST request failed: {e}")
+            click.echo(f"POST request failed: {e}")
+            raise e
+
+
+class AuthenticatedSession(CustomSession):
+    def __init__(self, access_token: str) -> None:
+        super().__init__()
+        self.access_token = access_token
+        self.headers.update({'Authorization': f'Bearer {self.access_token}'})
+
+
+class KaasClient:
+    _client: Client
+    _session: CustomSession
+    _url: str
+    _token: str | None
+    _vault: str | None
+
+    def __init__(
+            self,
+            url: str,
+            *,
+            token: str | None = None,
+            vault: str | None = None,
+    ) -> None:
+        self._url = url
+        self._token = token
+        self._vault = vault
+
+        self._configure_logging()
+        self._setup_client()
+        self._session = CustomSession()
+        if token:
+            self._session = AuthenticatedSession(token)
+        else:
+            self._load_session_if_exists()
+
+    def _setup_client(self) -> None:
+        """Setup the GraphQL client."""
+        transport = RequestsHTTPTransport(
+            url=f'{self._url}{GRAPHQL_URL}',
+            verify=True,
+        )
+        self._client = Client(transport=transport, fetch_schema_from_transport=True)
+
+    def _configure_logging(self) -> None:
+        """Configure logging for the application."""
+        if not CONFIG_LOG_PATH.exists():
+            CONFIG_LOG_PATH.parent.mkdir(parents=True, exist_ok=True)
+            CONFIG_LOG_PATH.touch()
+        logging.basicConfig(
+            filename=CONFIG_LOG_PATH,
+            filemode='a',
+            format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+            level=logging.DEBUG,
+        )
+
+    def _load_session_if_exists(self) -> None:
+        """Load session if the session file exists."""
+        if CONFIG_SESSION_PATH.exists():
+            self._load_session()
+
+    def hello(self, name: str | None = None) -> str:
+        response = self._client.execute(QUERY_HELLO, variable_values={'name': name} if name is not None else {})
+        return response['hello']
+
+    def _save_session(self, file_path: Path = CONFIG_SESSION_PATH) -> None:
+        file_path.parent.mkdir(parents=True, exist_ok=True)
+        with file_path.open('wb') as file:
+            pickle.dump(self._session, file)
+
+    def _load_session(self, file_path: Path = CONFIG_SESSION_PATH) -> None:
+        with file_path.open('rb') as file:
+            self._session = pickle.load(file)
+
+    def _remove_session(self, file_path: Path = CONFIG_SESSION_PATH) -> bool:
+        file_path.unlink()
+        return True
+
+    def _list_local_files(self, directory: str) -> list[Path]:
+        return [path for path in Path(directory).glob('**/*') if path.is_file()]
+
+    def list_local_proofs(self, directory: str) -> list[dict[str, Any]]:
+        list_local_files = [
+            {
+                'name': self._read_proof(path / 'proof.json').get('id'),
+                'size': size(sum(f.stat().st_size for f in path.glob('**/*') if f.is_file())),
+                'last_update_date': self._read_proof(path / 'proof.json').get('last_update_date'),
+            }
+            for path in Path(directory).glob('**/*')
+            if path.is_dir() and len(path.name.split(':')) == 2
+        ]
+        return list_local_files
+
+    def _read_proof(self, proof_path: Path) -> dict[str, Any]:
+        if not proof_path.exists():
+            return {'id': None, 'last_update_date': None}
+
+        with proof_path.open() as file:
+            data = json.load(file)
+            return {
+                'id': data.get('id'),
+                'last_update_date': datetime.fromtimestamp(os.path.getmtime(proof_path)).isoformat(),
+            }
+
+    def list_remote(self) -> Any:
+        try:
+            json_data = self._session.get(url=f'{self._url}{USER_URL}')
+        except Exception:
+            raise KaasCliException("List remote proofs failed") from None
+        return json_data
+
+    def _get_default_vault(self) -> str | None:
+        try:
+            json_data = self._session.get(url=f'{self._url}{USER_URL}')
+        except Exception:
+            raise KaasCliException("Get default vault failed") from None
+        vault_hash = jmespath.search('vaults[0].hash', json_data)
+        return vault_hash
+
+    def _get_upload_urls(self, metadata: dict[str, Any], vault: str) -> dict[str, Any]:
+        data = self._session.post(
+            url=f'{self._url}{FILES_URL.format(vault)}',
+            data=json.dumps(metadata),
+            headers={
+                'Content-Type': 'application/json',
+            },
+        )["data"]
+        return data
+
+    def _upload_presigned_url(self, files: dict[str, Any], directory: str = '') -> dict[str, Any]:
+        upload_results: Any = {}
+        for file_path_str, url in files.items():
+            file_path = Path(directory) / file_path_str
+            with file_path.open('rb') as file:
+                response = requests.put(url, data=file)
+
+                # Check if the upload was successful
+                if response.status_code in [200, 201]:  # Success status codes can vary, e.g., 200 OK or 201 Created
+                    print(f"Successfully uploaded: {file_path}")
+                    upload_results[file_path_str] = {'success': True, 'status_code': response.status_code}
+                else:
+                    print(f"Failed to upload {file_path.name} to {url}. Status code: {response.status_code}")
+                    upload_results[file_path_str] = {
+                        'success': False,
+                        'status_code': response.status_code,
+                        'error_message': response.text,
+                    }
+
+        return upload_results
+
+    def archive_files(self, file_list: List[Path], archive_name: str, archive_format: str = 'zip',
+                      root_dir: Path = None) -> str:
+        """
+        Archives a list of files into a single archive file while preserving the directory structure.
+
+        Args:
+        file_list (List[Path]): List of file paths to include in the archive.
+        archive_name (str): The name of the output archive file without extension.
+        archive_format (str): Format of the archive ('zip', 'tar', etc.). Default is 'zip'.
+        root_dir (Path): The root directory to use for preserving the relative paths. If None, the common parent of all files will be used.
+
+        Returns:
+        str: The path to the created archive file.
+        """
+        if root_dir is None:
+            # Find the common parent directory of all files
+            common_paths = Path(file_list[0]).parents
+            for file_path in file_list[1:]:
+                common_paths = set(common_paths) & set(Path(file_path).parents)
+            root_dir = min(common_paths, key=lambda p: len(p.parts))
+
+        # Ensure the archive name does not include an extension
+        archive_name = Path(archive_name).with_suffix('')
+
+        # Create a temporary directory to hold the files to be archived
+        with tempfile.TemporaryDirectory() as temp_dir:
+            temp_dir_path = Path(temp_dir)
+            for file_path in file_list:
+                if file_path.is_file():
+                    # Calculate relative path to the root_dir
+                    relative_path = file_path.relative_to(root_dir)
+                    # Create any necessary directories
+                    (temp_dir_path / relative_path).parent.mkdir(parents=True, exist_ok=True)
+                    # Copy file to the new location preserving the folder structure
+                    shutil.copy(file_path, temp_dir_path / relative_path)
+
+            # Create the archive from the temporary directory
+            archive_path = shutil.make_archive(archive_name, archive_format, root_dir=temp_dir_path)
+
+        # Move the archive to the desired directory and return the new path
+        final_archive_path = Path(archive_name).with_suffix(f'.{archive_format}')
+        shutil.move(archive_path, final_archive_path)
+
+        return str(final_archive_path)
+
+    def get_archive_metadata(self, archive_path: str) -> dict[str, Any]:
+        """
+        Extracts metadata from an archive file.
+
+        Args:
+        archive_path (str): Path to the archive file.
+
+        Returns:
+        dict[str, Any]: Metadata extracted from the archive file.
+        """
+        # Initialize an empty dictionary for metadata
+        metadata = {}
+
+        # Create a Path object from the archive_path
+        archive_file = Path(archive_path)
+
+        # Check if the archive file exists
+        if not archive_file.exists():
+            raise FileNotFoundError(f"The archive file {archive_path} does not exist.")
+        #             metadata[file_uuid] = {'filename': file_name_str, 'updated_at': updated_at}
+        # Try to extract metadata from the archive file
+        try:
+            metadata[archive_file.name] = {
+                'filename': archive_file.name,
+                'updated_at': datetime.fromtimestamp(archive_file.stat().st_mtime).isoformat(),
+            }
+        except Exception as e:
+            # Handle any exception that might occur during metadata extraction
+            raise e
+
+        return metadata
+
+    def get_version_from_digest(self, file_list) -> str:
+        """
+        Reads a JSON file named 'digest' from the provided file list, extracts hash values from specified fields, and returns them as a string.
+
+        Args:
+        file_list (list[Path]): List of file paths.
+
+        Returns:
+        str: A string containing the hash values from the 'digest' file.
+        """
+        # Find the 'digest' file in the file list
+        digest_file = next((file for file in file_list if file.name == 'digest'), None)
+        if digest_file is None:
+            raise FileNotFoundError("No 'digest' file found in the provided file list.")
+
+        # Read the 'digest' JSON file
+        with open(digest_file, 'r') as file:
+            data = json.load(file)
+
+        # Extract the hash values from specified fields
+        kompilation_hash = data.get('kompilation', 'Not found')
+        foundry_hash = data.get('foundry', 'Not found')
+
+        # Return the hash values as a string
+        return f"{kompilation_hash}{foundry_hash}"
+
+    def upload_files_s3(self, directory: str) -> str:
+        file_list = self._list_local_files(directory)
+        if not file_list or len(file_list) == 0:
+            raise ValueError(f'No files to upload in dir: {directory}')
+
+        archive_name = self.get_version_from_digest(file_list)
+        archive_path = self.archive_files(file_list, archive_name, archive_format='zip', root_dir=Path(directory))
+        metadata = self.get_archive_metadata(archive_path)
+        print(f"Uploading {metadata} to S3...")
+        vault: str | None = self._vault or self._get_default_vault()
+        if vault is None:
+            return UPLOAD_FAILURE_MESSAGE
+        urls = self._get_upload_urls(metadata=metadata, vault=vault)
+
+        try:
+            self._upload_presigned_url(urls)
+            print(UPLOAD_SUCCESS_MESSAGE)
+        except Exception as e:
+            raise KaasCliException(f"Failed to upload {archive_path} to S3: {e}") from None
+        # remove the archive file after uploading
+        os.remove(archive_path)
+
+    def process_archive(self, archive_path: str, extract_to: str) -> None:
+        """
+        Extracts files from an archive to a specified directory and then removes the archive.
+
+        Args:
+        archive_path (str): The path to the archive file.
+        extract_to (str): The directory to extract the files to.
+        """
+        # Ensure the target directory exists
+        os.makedirs(extract_to, exist_ok=True)
+
+        # Extract the archive
+        with ZipFile(archive_path, 'r') as zip_ref:
+            zip_ref.extractall(extract_to)
+
+        # Remove the archive file after extraction
+        os.remove(archive_path)
+        print(f"Extracted and removed archive {archive_path}")
+
+    def download_version(self, version_address: str, target_directory: str) -> Any:
+        vault_address = version_address.split('/')[0]
+        version = version_address.split('/')[1]
+        urls = self._get_download_url(vault_address)['data']
+        url = urls[version_address]['url']
+        if not url:
+            return f'Version {version_address} not found'
+
+        try:
+            downloaded_file_path = self.replace_path(version, target_directory)
+
+            self.download_file(url, self.replace_path(version, target_directory))
+            self.process_archive(downloaded_file_path, target_directory)
+        except Exception:
+            raise KaasCliException(f"Download {version} failed") from None
+
+        return f'Version {version} downloaded to {target_directory}'
+
+    def download_last_version(self, target_directory: str) -> Any:
+        vault_hash = self._vault or self._get_default_vault()
+        if not vault_hash:
+            return "Can't find default vault"
+
+        urls = self._get_download_url(vault_hash)
+
+        urls_data = urls.get('data', {})
+        if not urls_data:
+            return 'Something went wrong'
+
+        # Find the file with the latest date
+        latest_file = max(urls_data.items(), key=lambda x: x[1]['lastModified'])[0]
+        url = urls_data[latest_file]['url']
+
+        try:
+            downloaded_file_path = self.replace_path(latest_file, target_directory)
+            self.download_file(url, self.replace_path(latest_file, target_directory))
+            self.process_archive(downloaded_file_path, target_directory)
+        except Exception:
+            raise KaasCliException(f"Download {latest_file} failed") from None
+
+        return f'Latest version of {latest_file} downloaded to {target_directory}'
+
+    def process_archive(self, archive_path: str, extract_to: str) -> None:
+        """
+        Extracts files from an archive to a specified directory and then removes the archive.
+
+        Args:
+        archive_path (str): The path to the archive file.
+        extract_to (str): The directory to extract the files to.
+        """
+        # Ensure the target directory exists
+        os.makedirs(extract_to, exist_ok=True)
+
+        # Extract the archive
+        with ZipFile(archive_path, 'r') as zip_ref:
+            zip_ref.extractall(extract_to)
+
+        # Remove the archive file after extraction
+        os.remove(archive_path)
+        print(f"Extracted and removed archive {archive_path}")
+
+    def download_last_version(self, target_directory: str) -> Any:
+        vault_hash = self._vault or self._get_default_vault()
+        if not vault_hash:
+            return "Can't find default vault"
+
+        urls = self._get_download_url(vault_hash)
+
+        urls_data = urls.get('data', {})
+        if not urls_data:
+            return 'Something went wrong'
+
+
+        # Find the file with the latest date
+        latest_file = max(urls_data.items(), key=lambda x: x[1]['lastModified'])[0]
+        url = urls_data[latest_file]['url']
+
+        try:
+            downloaded_file_path = self.replace_path(latest_file, target_directory)
+            self.download_file(url, self.replace_path(latest_file, target_directory))
+            self.process_archive(downloaded_file_path, target_directory)
+        except Exception:
+            raise KaasCliException(f"Download {latest_file} failed") from None
+
+        return f'Latest version of {latest_file} downloaded to {target_directory}'
+
+    def download_vault(self, target_directory: str) -> Any:
+        vault_hash = self._vault or self._get_default_vault()
+        if not vault_hash:
+            return "Can't find default vault"
+
+        urls = self._get_download_url(vault_hash)
+
+        urls_data = urls.get('data', {})
+        if not urls_data:
+            return 'Something went wrong'
+
+        for path in urls_data:
+            print(path)
+
+            url = urls_data[path]
+            try:
+                self.download_file(url, self.replace_path(path, target_directory))
+            except Exception:
+                raise KaasCliException(f"Download {path} failed") from None
+
+        return f'{len(urls_data)} Files downloaded to {target_directory}'
+
+    @staticmethod
+    def _get_upload_data(file_list: list[Path], directory: Path) -> tuple[File_Data, Metadata]:
+        data: File_Data = {}
+        metadata = {}
+
+        for file_path in file_list:
+            file_uuid = str(uuid4())
+            file_name_str = Path(file_path).relative_to(directory).as_posix()
+            with file_path.open('rb') as file_object:
+                data[f'file_{file_uuid}'] = (file_name_str, file_object.read(), None)
+            updated_at = datetime.fromtimestamp(os.path.getmtime(file_path)).strftime('%Y-%m-%d %H:%M:%S')
+            # Ensure the file path is converted to a string
+            metadata[file_uuid] = {'filename': file_name_str, 'updated_at': updated_at}
+
+        data['metadata'] = (None, json.dumps(metadata), 'application/json')
+
+        return data, metadata
+
+    @staticmethod
+    def _get_metadata(file_list: list[Path], directory: Path) -> Metadata:
+        data, metadata = KaasClient._get_upload_data(file_list, Path(directory))
+        return metadata
+
+    def login(self) -> DeviceAuth:
+        try:
+            data = self._session.post(url=f'{self._url}{DEVICE_LOGIN_URL}')
+        except Exception:
+            raise KaasCliException("Login failed") from None
+        return DeviceAuth(**data)
+
+    def confirm_login(self, device_code: str) -> Confirmation:
+        try:
+            data = self._session.get(url=f'{self._url}{DEVICE_LOGIN_URL}', params={'device_code': device_code})
+        except Exception:
+            raise KaasCliException("Login failed") from None
+        self._session = AuthenticatedSession(data['token'])
+        self._save_session()
+        return Confirmation(True)
+
+    def check(self) -> Confirmation:
+        data = self._session.get(url=f'{self._url}{USER_URL}')
+        if data:
+            return Confirmation(True)
+        else:
+            return Confirmation(False)
+
+    def _get_download_url(self, vault_hash: str) -> dict:
+        data = self._session.get(url=f'{self._url}{FILES_URL.format(vault_hash)}')
+        return data
+
+    def download_file(self, url: str, folder_path: str) -> None:
+        file_path = Path(folder_path)
+
+        file_path.parent.mkdir(parents=True, exist_ok=True)
+        with requests.get(url, stream=True) as response:
+            # Check if the request was successful
+            response.raise_for_status()
+            # Open a local file with write-binary mode in the specified folder
+            with open(file_path, 'wb') as file:
+                # Write the content of the response to the file in chunks
+                for chunk in response.iter_content(chunk_size=8192):
+                    file.write(chunk)
+
+    def replace_path(self, input_string: str, target_directory: str) -> str:
+
+        # Find the index of the first dash '/'
+        dash_index = input_string.find('/')
+
+        # Replace everything up to the first dash with 'test'
+        result = target_directory + input_string[dash_index:]
+
+        return result
+
+    def read_new_files(self, files: list[str], target_directory: str) -> list[str]:
+        new_files = []
+        for file_name in files:
+            file_path = Path(target_directory, file_name)
+            if not file_path.exists():
+                new_files.append(file_name)
+        return new_files
+
+    def pull_remote_files(self, files: list[str]) -> list[str]:
+        try:
+            data = self._session.get(url=f'{self._url}{FILES_LIST_URL}', params={'files': files})
+        except Exception:
+            raise KaasCliException("Pull remote files failed") from None
+        return data
+
+    def list_vaults(self) -> list[str]:
+        try:
+            data = self._session.get(url=f'{self._url}{VAULTS_ROOT_URL}')
+        except Exception:
+            raise KaasCliException("List vaults failed") from None
+        return data
+
+    def list_keys(self, vault: str) -> list[str]:
+        try:
+            data = self._session.get(url=f'{self._url}{VAULTS_KEY_URL.format(vault)}')['data']
+        except Exception:
+            raise KaasCliException("List vaults failed") from None
+        return data
+
+    def list_versions(self, vault: str) -> list[str]:
+        try:
+            data = self._get_download_url(vault)
+            print(data)
+        except Exception:
+            raise KaasCliException("List vaults failed") from None
+        return data
+
+    def logout(self) -> bool:
+        """
+        Log out the user by clearing the session and authentication token.
+        Returns True if the logout was successful, False otherwise.
+        """
+        try:
+            return self._remove_session()
+        except Exception as e:
+            logging.error(f"Logout failed: {e}")
+            return False
+
+
+QUERY_HELLO: Final = gql(
+    """
+    query Hello($name: String!) {
+        hello(name: $name)
+    }
+    """
+)

kaas_cli-0.1.1/src/kaas_cli/config.py

@@ -0,0 +1,36 @@
+import os
+from typing import Any
+
+import click
+from dotenv import load_dotenv
+
+load_dotenv()
+
+from dotenv import load_dotenv
+
+from .constants import DEFAULT_K_OUT_FOLDER, DEFAULT_PROD_SERVER_URL
+
+# Load environment variables from .flaskenv file
+load_dotenv('.flaskenv')
+
+DEFAULT_DIRECTORY = os.getenv('DEFAULT_DIRECTORY') or DEFAULT_K_OUT_FOLDER
+SERVER_URL = os.getenv('SERVER_URL') or DEFAULT_PROD_SERVER_URL
+DEFAULT_PROJECT_ID = os.getenv('DEFAULT_PROJECT_ID')
+DEFAULT_TOKEN = os.getenv('DEFAULT_TOKEN')
+
+
+class CustomHelpOption(click.Command):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        self.aliases = kwargs.pop('aliases', [])
+        super().__init__(*args, **kwargs)
+
+    def format_aliases(self) -> str:
+        return f"Aliases: {', '.join(repr(alias) for alias in self.aliases)}" if self.aliases else ""
+
+    def get_short_help_str(self, limit: int = 45) -> str:
+        short_help = super().get_short_help_str(limit)
+        aliases_text = self.format_aliases()
+        return f"{short_help}. {aliases_text}" if aliases_text else short_help
+
+    def get_help(self, ctx):
+        return super().get_help(ctx)

kaas_cli-0.1.1/src/kaas_cli/constants.py

@@ -0,0 +1,27 @@
+from pathlib import Path
+from typing import Final
+
+CONFIG_DIR_PATH: Final = Path(__file__).parent.parent / 'config'
+CONFIG_FILE_PATH: Final = CONFIG_DIR_PATH / 'config.ini'
+CONFIG_LOG_PATH: Final = CONFIG_DIR_PATH / 'kaas.log'
+CONFIG_SESSION_PATH: Final = CONFIG_DIR_PATH / 'session.pkl'
+
+GRAPHQL_URL: Final = '/graphql'
+FILES_ROOT_URL: Final = '/api/files'
+FILES_URL: Final = '/api/files/{}/url'
+FILES_LIST_URL: Final = '/api/files/list'
+FILES_UPLOAD_URL: Final = '/api/files/upload'
+
+DEVICE_LOGIN_URL: Final = '/api/login/github/device'
+USER_URL: Final = '/api/user/'
+
+VAULTS_ROOT_URL: Final = '/api/vaults/'
+VAULTS_KEY_URL: Final = '/api/vaults/{}/keys'
+
+UPLOAD_SUCCESS_MESSAGE: Final = 'Data successfully uploaded'
+UPLOAD_FAILURE_MESSAGE: Final = 'Failed to upload file'
+
+DEFAULT_DEV_SERVER_URL: Final = 'http://127.0.0.1:5000'
+DEFAULT_PROD_SERVER_URL: Final = 'https://kaas.runtimeverification.com/'
+
+DEFAULT_K_OUT_FOLDER: Final = './kout'

kaas_cli-0.1.1/src/kaas_cli/hello.py

@@ -0,0 +1,2 @@
+def hello(name: str) -> str:
+    return f'Hello, {name}!'

kaas_cli-0.1.1/src/kaas_cli/types.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from typing import IO, Any, Optional
+
+from click import ClickException, echo
+
+File_Data = dict[str, tuple[Optional[str], Any, Optional[str]]]
+Metadata = dict[str, Any]
+
+
+class KaasCliException(ClickException):
+    def show(self, file: IO[Any] | None = None) -> None:
+        echo(f'{self.message}', file=file)