artefacts-cli 0.6.13__tar.gz → 0.6.17__tar.gz

{artefacts_cli-0.6.13 → artefacts_cli-0.6.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: artefacts_cli
-Version: 0.6.13
+Version: 0.6.17
 Author-email: FD <fabian@artefacts.com>, AGC <alejandro@artefacts.com>, TN <tomo@artefacts.com>, EP <eric@artefacts.com>
 Project-URL: Homepage, https://github.com/art-e-fact/artefacts-client
 Project-URL: Bug Tracker, https://github.com/art-e-fact/artefacts-client/issues
@@ -18,9 +18,11 @@ Requires-Dist: mcap-ros2-support
 Requires-Dist: PyYAML>=6.0
 Requires-Dist: requests>=2.27.1
 Requires-Dist: setuptools-scm
+Requires-Dist: setuptools>=74
 Provides-Extra: dev
 Requires-Dist: awscli; extra == "dev"
 Requires-Dist: build; extra == "dev"
+Requires-Dist: docker; extra == "dev"
 Requires-Dist: lark; extra == "dev"
 Requires-Dist: pyre-check; extra == "dev"
 Requires-Dist: pytest; extra == "dev"

{artefacts_cli-0.6.13 → artefacts_cli-0.6.17}/artefacts/cli/__init__.py

@@ -15,7 +15,7 @@ logging.basicConfig(level=logging.INFO)
 
 
 try:
-    __version__ = version("package-name")
+    __version__ = version("artefacts-cli")
 except PackageNotFoundError:
     try:
         # Package is not installed, most likely dev/test mode

{artefacts_cli-0.6.13 → artefacts_cli-0.6.17}/artefacts/cli/app.py

@@ -9,7 +9,6 @@ import sys
 import tarfile
 import tempfile
 import time
-from typing import Any, Union
 from urllib.parse import urlparse
 import webbrowser
 
@@ -20,7 +19,9 @@ from pathlib import Path
 from gitignore_parser import parse_gitignore
 
 from artefacts.cli import init_job, generate_scenarios, AuthenticationError, __version__
+from artefacts.cli import app_containers as containers
 from artefacts.cli.constants import DEPRECATED_FRAMEWORKS, SUPPORTED_FRAMEWORKS
+from artefacts.cli.utils import read_config, config_validation
 import artefacts_copava as copava
 
 HOME = os.path.expanduser("~")
@@ -100,55 +101,10 @@ class APIConf:
         click.echo(f"Connecting to {self.api_url} using {auth_type}")
 
 
-def read_config(filename: str) -> dict:
-    try:
-        with open(filename) as f:
-            return copava.parse(f.read())
-    except FileNotFoundError:
-        raise click.ClickException(f"Project config file {filename} not found.")
-
-
 def validate_artefacts_config(config_file: str) -> dict:
     pass
 
 
-def pretty_print_config_error(
-    errors: Union[str, list, dict], indent: int = 0, prefix: str = "", suffix: str = ""
-) -> str:
-    if type(errors) is str:
-        header = "  " * indent
-        output = header + prefix + errors + suffix
-    elif type(errors) is list:
-        _depth = indent + 1
-        output = []
-        for value in errors:
-            output.append(pretty_print_config_error(value, indent=_depth, prefix="- "))
-        output = os.linesep.join(output)
-    elif type(errors) is dict:
-        _depth = indent + 1
-        output = []
-        for key, value in errors.items():
-            output.append(pretty_print_config_error(key, indent=indent, suffix=":"))
-            output.append(pretty_print_config_error(value, indent=_depth))
-        output = os.linesep.join(output)
-    else:
-        # Must not happen, so broad definition, but we want to know fast.
-        raise Exception(f"Unacceptable data type for config error formatting: {errors}")
-    return output
-
-
-# Click callback syntax
-def config_validation(context: dict, param: str, value: str) -> str:
-    if context.params["skip_validation"]:
-        return value
-    config = read_config(value)
-    errors = copava.check(config)
-    if len(errors) == 0:
-        return value
-    else:
-        raise click.BadParameter(pretty_print_config_error(errors))
-
-
 @click.group()
 def config():
     return
@@ -275,11 +231,64 @@ def hello(project_name):
     is_eager=True,  # Necessary for callbacks to see it.
     help="Skip configuration validation, so that unsupported settings can be tried out, e.g. non-ROS settings or simulators like SAPIEN.",
 )
+@click.option(
+    "--in-container",
+    is_flag=True,
+    default=False,
+    help='[Experimental] Run the job inside a package container. The container image is build if it does not exist yet, with default name as "artefacts" (please use --with-image to override the image name). This option overrides (for now) --dryrun, --nosim, --noisolation and --description.',
+)
+@click.option(
+    "--with-image",
+    default="artefacts",
+    help="[Experimental] Run the job using the image name passed here. Only used when running with --in-container set.",
+)
+@click.option(
+    "--rebuild-container",
+    is_flag=True,
+    default=False,
+    help="[Experimental] Rebuild the container image before running. This flag guarantees that the run uses the latest code available when building the image, and usually takes more time before the run can start (time to compile and generate the image).",
+)
+@click.option(
+    "--with-gui",
+    is_flag=True,
+    default=False,
+    help="Show any GUI if any is created by the test runs. By default, UI elements are run but hidden---only test logs are returned. Please note GUI often assume X11 (e.g. ROS), typically with Qt, so this may not work without a appropriate environment.",
+)
 @click.argument("jobname")
+@click.pass_context
 def run(
-    config, jobname, dryrun, nosim, noisolation, description="", skip_validation=False
+    ctx: click.Context,
+    config,
+    jobname,
+    dryrun,
+    nosim,
+    noisolation,
+    description="",
+    skip_validation=False,
+    in_container: bool = False,
+    with_image: str = "artefacts",
+    rebuild_container: bool = False,
+    with_gui: bool = False,
 ):
-    """Run JOBNAME locally"""
+    """
+    Run JOBNAME locally
+
+    * Directly in the shell by default.
+    * Inside a packaged container when using the --in-container option.
+    """
+    if in_container:
+        if rebuild_container or not ctx.invoke(containers.check, name=with_image):
+            ctx.invoke(
+                containers.build, path=".", dockerfile="Dockerfile", name=with_image
+            )
+        return ctx.invoke(
+            containers.run,
+            image=with_image,
+            jobname=jobname,
+            config=config,
+            with_gui=with_gui,
+        )
+
     warpconfig = read_config(config)
 
     project_id = warpconfig["project"]
@@ -334,7 +343,7 @@ def run(
         )
     except AuthenticationError:
         raise click.ClickException(
-            "Unable to authenticate, check your Project Name and API Key"
+            "Unable to authenticate (Stage: Job initialisation), please check your project name and API key"
         )
 
     job_success = True
@@ -346,7 +355,7 @@ def run(
             run = warpjob.new_run(scenario)
         except AuthenticationError:
             raise click.ClickException(
-                "Unable to authenticate, check your Project Name and API Key"
+                "Unable to authenticate (Stage: Job run), please check your project name and API key"
             )
         if framework is not None and framework.startswith("ros2:"):
             from artefacts.cli.ros2 import run_ros2_tests
@@ -474,7 +483,7 @@ def run_remote(config, description, jobname, skip_validation=False):
     click.echo(f"Packaging source...")
 
     with tempfile.NamedTemporaryFile(
-        prefix=project_id, suffix=".tgz", delete=True
+        prefix=project_id.split("/")[-1], suffix=".tgz", delete=True
     ) as temp_file:
         # get list of patterns to be ignored in .artefactsignore
         ignore_file = Path(project_folder) / Path(".artefactsignore")
@@ -512,7 +521,13 @@ def run_remote(config, description, jobname, skip_validation=False):
         )
 
         if not upload_urls_response.ok:
-            result = upload_urls_response.json()
+            try:
+                result = upload_urls_response.json()
+            except requests.exceptions.JSONDecodeError:
+                raise click.ClickException(
+                    f"Apologies, problem in interacting with the Artefacts backend: {upload_urls_response.status_code} {upload_urls_response.reason}. Response text: {upload_urls_response.text}."
+                )
+
             if (
                 upload_urls_response.status_code == 403
                 and result["message"] == "Not allowed"
@@ -611,6 +626,7 @@ artefacts.add_command(config)
 artefacts.add_command(hello)
 artefacts.add_command(run)
 artefacts.add_command(run_remote)
+artefacts.add_command(containers.containers)
 
 
 if __name__ == "__main__":

artefacts_cli-0.6.17/artefacts/cli/app_containers.py

@@ -0,0 +1,98 @@
+import os
+
+import click
+
+from artefacts.cli.constants import DEFAULT_API_URL
+from artefacts.cli.utils import config_validation, read_config
+from artefacts.cli.containers.utils import ContainerMgr
+
+
+@click.group()
+@click.option("--debug/--no-debug", default=False)
+@click.pass_context
+def containers(ctx: click.Context, debug: bool):
+    ctx.ensure_object(dict)
+    ctx.obj["debug"] = debug
+
+
+@containers.command()
+@click.option(
+    "--path",
+    default=".",
+    help="Path to the root of the project, where a Dockerfile is available.",
+)
+@click.option(
+    "--dockerfile",
+    default="Dockerfile",
+    help="File name of the container definition file. Defaults to the standard Dockerfile inside the project root (see --path)",
+)
+@click.option(
+    "--name",
+    required=False,
+    help="Name for the generated container",
+)
+@click.pass_context
+def build(ctx: click.Context, path: str, dockerfile: str, name: str):
+    if not os.path.exists(os.path.join(path, dockerfile)):
+        raise click.ClickException(
+            f"No {dockerfile} found here. I cannot build the container."
+        )
+    if name is None:
+        name = "artefacts"
+    handler = ContainerMgr()
+    image, _ = handler.build(path=path, name=name)
+    print(f"Package complete in image: {image}")
+
+
+@containers.command()
+@click.argument("name")
+@click.pass_context
+def check(ctx: click.Context, name: str):
+    if name is None:
+        name = "artefacts"
+    handler = ContainerMgr()
+    result = handler.check(name)
+    if ctx.parent is None:
+        # Print only if the command is called directly.
+        print(f"Package {name} exists and ready to use.")
+    return result
+
+
+@containers.command()
+@click.argument("image")
+@click.argument("jobname")
+@click.option(
+    "--config",
+    callback=config_validation,
+    default="artefacts.yaml",
+    help="Artefacts config file.",
+)
+@click.option(
+    "--with-gui",
+    "with_gui",
+    default=False,
+    help="Show any GUI if any is created by the test runs. By default, UI elements are run but hidden---only test logs are returned. Please note GUI often assume an X11 environment, typically with Qt, so this may not work without a appropriate environment.",
+)
+@click.pass_context
+def run(ctx: click.Context, image: str, jobname: str, config: str, with_gui: bool):
+    try:
+        artefacts_config = read_config(config)
+    except FileNotFoundError:
+        raise click.ClickException(f"Project config file not found: {config}")
+    project = artefacts_config["project"]
+    handler = ContainerMgr()
+    params = dict(
+        image=image,
+        project=project,
+        jobname=jobname,
+        # Hidden setting primarily useful to Artefacts developers
+        api_url=os.environ.get("ARTEFACTS_API_URL", DEFAULT_API_URL),
+        with_gui=with_gui,
+    )
+    container, logs = handler.run(**params)
+    if container:
+        print(f"Package run complete: Container Id for inspection: {container['Id']}")
+    else:
+        print(f"Package run failed:")
+        for entry in logs:
+            print("\t- " + entry)

{artefacts_cli-0.6.13 → artefacts_cli-0.6.17}/artefacts/cli/constants.py

@@ -1,3 +1,5 @@
+DEFAULT_API_URL = "https://app.artefacts.com/api"
+
 SUPPORTED_FRAMEWORKS = [
     "ros2:iron",
     "ros2:humble",

artefacts_cli-0.6.17/artefacts/cli/containers/__init__.py

@@ -0,0 +1,68 @@
+from collections.abc import Generator
+import configparser
+import os
+from pathlib import Path
+from typing import Any, Tuple, Union
+
+from artefacts.cli.constants import DEFAULT_API_URL
+
+
+class CMgr:
+    def build(self, **kwargs) -> Tuple[str, Generator]:
+        """
+        Returns the build image ID (e.g. sha256:abcdefghi)
+        and an iterator over the build log entries.
+        """
+        raise NotImplemented()
+
+    def check(self, image: str) -> bool:
+        """
+        Checks whether a target image exists locally.
+        """
+        raise NotImplemented()
+
+    def run(
+        self,
+        image: str,
+        project: str,
+        jobname: str = None,
+        artefacts_dir: str = Path("~/.artefacts").expanduser(),
+        api_url: str = DEFAULT_API_URL,
+        with_gui: bool = False,
+    ) -> Tuple[Any, Generator]:
+        """
+        Returns a container (Any type as depends on the framework)
+        and an iterator over the container log entries.
+        """
+        raise NotImplemented()
+
+    def _valid_artefacts_api_key(
+        self, project: str, path: Union[str, Path] = Path("~/.artefacts").expanduser()
+    ) -> bool:
+        """
+        Check if a valid API key is available to embed in containers.
+
+        1. Check overrides with the ARTEFACTS_KEY environment variable.
+        2. If `path` is not given, check the default .artefacts folder for the config file.
+        3. If `path` is given, check the file directly is a file, or check for a `config` file if a folder.
+
+        When a config file is found, we check here if the API key for the `project` is available.
+
+        `path` set to None is an error, and aborts execution.
+        """
+        if not path:
+            raise Exception(
+                "`path` must be a string, a Path object, or excluded from the kwargs"
+            )
+        if os.environ.get("ARTEFACTS_KEY", None):
+            return True
+        path = Path(path)  # Ensure we have a Path object
+        config = configparser.ConfigParser()
+        if path.is_dir():
+            config.read(path / "config")
+        else:
+            config.read(path)
+        try:
+            return config[project].get("apikey") != None
+        except KeyError:
+            return False

artefacts_cli-0.6.17/artefacts/cli/containers/docker.py

@@ -0,0 +1,104 @@
+from collections.abc import Generator
+import json
+import os
+from pathlib import Path
+import platform
+from typing import Any, Tuple
+from uuid import uuid4
+
+from artefacts.cli.constants import DEFAULT_API_URL
+from artefacts.cli.containers import CMgr
+from artefacts.cli.utils import ensure_available
+
+ensure_available("docker")
+
+import docker
+from docker import APIClient
+
+
+class DockerManager(CMgr):
+    def __init__(self):
+        self.client = APIClient()
+
+    def build(self, **kwargs) -> Tuple[str, Generator]:
+        kwargs["tag"] = kwargs.pop("name")
+        logs = []
+        img_id = None
+        for entry in self.client.build(**kwargs):
+            line_data = [
+                json.loads(v) for v in entry.decode("utf-8").split("\r\n") if len(v) > 0
+            ]
+            for data in line_data:
+                if "stream" in data:
+                    line = data["stream"].strip()
+                    if not line.startswith("---") and len(line) > 0:
+                        print(line)
+                        logs.append(line)
+                elif "aux" in data and "ID" in data["aux"]:
+                    img_id = data["aux"]["ID"]
+        if img_id is None:
+            img_id = self.client.inspect_image(kwargs["tag"])["Id"]
+        return img_id, iter(logs)
+
+    def check(
+        self,
+        image: str,
+    ) -> bool:
+        return len(self.client.images(name=image)) > 0
+
+    def run(
+        self,
+        image: str,
+        project: str,
+        jobname: str = None,
+        artefacts_dir: str = Path("~/.artefacts").expanduser(),
+        api_url: str = DEFAULT_API_URL,
+        with_gui: bool = False,
+    ) -> Tuple[Any, Generator]:
+        if not self._valid_artefacts_api_key(project, artefacts_dir):
+            return None, iter(
+                [
+                    "Missing API key for the project. Does `~/.artefacts/config` exist and contain your key?"
+                ]
+            )
+        try:
+            env = {
+                "JOB_ID": str(uuid4()),
+                "ARTEFACTS_JOB_NAME": jobname,
+                "ARTEFACTS_API_URL": api_url,
+            }
+
+            if platform.system() in ["Darwin", "Windows"]:
+                # Assume we run in Docker Desktop
+                env["DISPLAY"] = "host.docker.internal:0"
+            else:
+                env["DISPLAY"] = os.environ.get("DISPLAY", ":0")
+
+            if not with_gui:
+                env["QT_QPA_PLATFORM"] = "offscreen"
+
+            container = self.client.create_container(
+                image,
+                environment=env,
+                detach=False,
+                volumes=["/root/.artefacts"],
+                host_config=self.client.create_host_config(
+                    binds={
+                        artefacts_dir: {
+                            "bind": "/root/.artefacts",
+                            "mode": "ro",
+                        },
+                    },
+                    network_mode="host",
+                ),
+            )
+            self.client.start(container=container.get("Id"))
+            for entry in self.client.logs(container=container.get("Id"), stream=True):
+                print(entry.decode("utf-8").strip())
+            return container, iter([])
+        except docker.errors.ImageNotFound:
+            return None, iter(
+                [f"Image {image} not found by Docker. Perhaps need to build first?"]
+            )
+        except Exception as e:
+            return None, iter([f"Failed to run from {image}. All we know: {e}"])

artefacts_cli-0.6.17/artefacts/cli/containers/utils.py

@@ -0,0 +1,57 @@
+from collections.abc import Generator
+import logging
+from typing import Any, Tuple
+
+from artefacts.cli.containers import CMgr
+
+
+class ContainerMgr:
+    SUPPORTED_PRIORITISED_ENGINES = {
+        1: "docker",
+        # 2: "podman",
+    }
+
+    def __init__(self):
+        self.logger = logging.getLogger(__name__)
+        self.mgr = self._configure()
+        if self.mgr is None:
+            raise Exception(
+                f"Failed to find supported container stack. Please install and start one in {list(self.SUPPORTED_PRIORITISED_ENGINES.values())}, with default settings (custom sockets not supported at this stage)"
+            )
+
+    def _configure(self) -> CMgr:
+        manager = None
+        for idx in sorted(self.SUPPORTED_PRIORITISED_ENGINES):
+            engine = self.SUPPORTED_PRIORITISED_ENGINES[idx]
+            try:
+                handler = getattr(self, f"_configure_{engine}")
+                manager = handler()
+            except AttributeError:
+                self.logger.warning(
+                    f"Tried to detect an unsupported engine: {engine}. WIP? Ignore and continue."
+                )
+            except Exception as e:
+                self.logger.warning(
+                    f"Problem in detecting {engine} ({e}) Ignore and continue."
+                )
+            if manager is not None:
+                break
+        return manager
+
+    def _configure_docker(self):
+        from artefacts.cli.containers.docker import DockerManager
+
+        return DockerManager()
+
+    # def _configure_podman(self):
+    #     from artefacts.cli.containers import podman
+    #     return PodmanManager()
+
+    def build(self, **kwargs) -> Tuple[str, Generator]:
+        return self.mgr.build(**kwargs)
+
+    def check(self, image: str) -> bool:
+        return self.mgr.check(image)
+
+    def run(self, **kwargs) -> Tuple[Any, Generator]:
+        return self.mgr.run(**kwargs)

artefacts_cli-0.6.17/artefacts/cli/utils.py

@@ -0,0 +1,99 @@
+import os
+import subprocess
+import sys
+from typing import Any, Union
+
+import click
+
+import artefacts_copava as copava
+
+
+def run_and_save_logs(
+    args, output_path, shell=False, executable=None, env=None, cwd=None
+):
+    """
+    Run a command and save stdout and stderr to a file in output_path
+
+    Note: explicitly list used named params instead of using **kwargs to avoid typing issue: https://github.com/microsoft/pyright/issues/455#issuecomment-780076232
+    """
+    output_file = open(output_path, "wb")
+    proc = subprocess.Popen(
+        args,
+        stdout=subprocess.PIPE,  # Capture stdout
+        stderr=subprocess.PIPE,  # Capture stderr
+        shell=shell,
+        executable=executable,
+        env=env,
+        cwd=cwd,
+    )
+    # write test-process stdout and stderr into file and stdout
+    if proc.stdout:
+        for line in proc.stdout:
+            decoded_line = line.decode()
+            sys.stdout.write(decoded_line)
+            output_file.write(line)
+    if proc.stderr:
+        for line in proc.stderr:
+            decoded_line = line.decode()
+            sys.stderr.write(decoded_line)
+            output_file.write(line)
+    proc.wait()
+    return proc.returncode
+
+
+def ensure_available(package: str) -> None:
+    import importlib
+
+    try:
+        importlib.import_module(package)
+    except ImportError:
+        """
+        Recommended by the Python community
+        https://pip.pypa.io/en/latest/user_guide/#using-pip-from-your-program
+        """
+        subprocess.check_call([sys.executable, "-m", "pip", "install", package])
+
+
+def read_config(filename: str) -> dict:
+    try:
+        with open(filename) as f:
+            return copava.parse(f.read())
+    except FileNotFoundError:
+        raise click.ClickException(f"Project config file {filename} not found.")
+
+
+# Click callback syntax
+def config_validation(context: dict, param: str, value: str) -> str:
+    if context.params.get("skip_validation", False):
+        return value
+    config = read_config(value)
+    errors = copava.check(config)
+    if len(errors) == 0:
+        return value
+    else:
+        raise click.BadParameter(pretty_print_config_error(errors))
+
+
+def pretty_print_config_error(
+    errors: Union[str, list, dict], indent: int = 0, prefix: str = "", suffix: str = ""
+) -> str:
+    if type(errors) is str:
+        header = "  " * indent
+        output = header + prefix + errors + suffix
+    elif type(errors) is list:
+        _depth = indent + 1
+        output = []
+        for value in errors:
+            output.append(pretty_print_config_error(value, indent=_depth, prefix="- "))
+        output = os.linesep.join(output)
+    elif type(errors) is dict:
+        _depth = indent + 1
+        output = []
+        for key, value in errors.items():
+            output.append(pretty_print_config_error(key, indent=indent, suffix=":"))
+            output.append(pretty_print_config_error(value, indent=_depth))
+        output = os.linesep.join(output)
+    else:
+        # Must not happen, so broad definition, but we want to know fast.
+        raise Exception(f"Unacceptable data type for config error formatting: {errors}")
+    return output

{artefacts_cli-0.6.13 → artefacts_cli-0.6.17}/artefacts/cli/version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.6.13'
-__version_tuple__ = version_tuple = (0, 6, 13)
+__version__ = version = '0.6.17'
+__version_tuple__ = version_tuple = (0, 6, 17)

{artefacts_cli-0.6.13 → artefacts_cli-0.6.17}/artefacts.yaml

@@ -1,6 +1,6 @@
 version: 0.1.0
 
-project: client-test-platform
+project: artefacts-tests/cli-run-remote-testing
 
 on:
   push:
@@ -23,7 +23,7 @@ jobs:
     timeout: 5 # minutes
     scenarios:
       defaults: # Global to all scenarios, and overriden in specific scenarios.
-        output_dirs: 
+        output_dirs:
           - /tmp/outputs/
         subscriptions:
           pose: turtle1/pose
@@ -55,4 +55,4 @@ jobs:
           pose: turtle1/pose
       settings:
         - name: turtle
-          ros_testfile: infra-tests/turtlesim2/launch_turtle.py
+          ros_testfile: infra-tests/turtlesim2/launch_turtle.py

{artefacts_cli-0.6.13 → artefacts_cli-0.6.17}/artefacts_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: artefacts_cli
-Version: 0.6.13
+Version: 0.6.17
 Author-email: FD <fabian@artefacts.com>, AGC <alejandro@artefacts.com>, TN <tomo@artefacts.com>, EP <eric@artefacts.com>
 Project-URL: Homepage, https://github.com/art-e-fact/artefacts-client
 Project-URL: Bug Tracker, https://github.com/art-e-fact/artefacts-client/issues
@@ -18,9 +18,11 @@ Requires-Dist: mcap-ros2-support
 Requires-Dist: PyYAML>=6.0
 Requires-Dist: requests>=2.27.1
 Requires-Dist: setuptools-scm
+Requires-Dist: setuptools>=74
 Provides-Extra: dev
 Requires-Dist: awscli; extra == "dev"
 Requires-Dist: build; extra == "dev"
+Requires-Dist: docker; extra == "dev"
 Requires-Dist: lark; extra == "dev"
 Requires-Dist: pyre-check; extra == "dev"
 Requires-Dist: pytest; extra == "dev"

{artefacts_cli-0.6.13 → artefacts_cli-0.6.17}/artefacts_cli.egg-info/SOURCES.txt

@@ -5,6 +5,7 @@ pyproject.toml
 pytest.ini
 artefacts/cli/__init__.py
 artefacts/cli/app.py
+artefacts/cli/app_containers.py
 artefacts/cli/bagparser.py
 artefacts/cli/constants.py
 artefacts/cli/other.py
@@ -14,6 +15,9 @@ artefacts/cli/ros2.py
 artefacts/cli/utils.py
 artefacts/cli/utils_ros.py
 artefacts/cli/version.py
+artefacts/cli/containers/__init__.py
+artefacts/cli/containers/docker.py
+artefacts/cli/containers/utils.py
 artefacts/wrappers/artefacts_ros1_meta.launch
 artefacts_cli.egg-info/PKG-INFO
 artefacts_cli.egg-info/SOURCES.txt
@@ -40,6 +44,7 @@ tests/__init__.py
 tests/conftest.py
 tests/test_config_validation.py
 tests/cli/__init__.py
+tests/cli/test_app_containers.py
 tests/cli/test_cli.py
 tests/cli/test_config_validation.py
 tests/cli/test_other.py
@@ -50,4 +55,5 @@ tests/cli/test_warp.py
 tests/fixtures/artefacts_deprecated.yaml
 tests/fixtures/artefacts_ros1.yaml
 tests/fixtures/warp-env-param.yaml
-tests/fixtures/warp.yaml
+tests/fixtures/warp.yaml
+tests/utils/docker_mock.py

{artefacts_cli-0.6.13 → artefacts_cli-0.6.17}/artefacts_cli.egg-info/requires.txt

@@ -7,10 +7,12 @@ mcap-ros2-support
 PyYAML>=6.0
 requests>=2.27.1
 setuptools-scm
+setuptools>=74
 
 [dev]
 awscli
 build
+docker
 lark
 pyre-check
 pytest

{artefacts_cli-0.6.13 → artefacts_cli-0.6.17}/pyproject.toml

@@ -28,6 +28,7 @@ dependencies = [
   "PyYAML>=6.0",
   "requests>=2.27.1",
   "setuptools-scm",
+  "setuptools>=74", # setuptools-scm requires without version, but does not work with oldish versions, so let's ensure a recent, tested one.
 ]
 dynamic = ["version"]
 
@@ -42,6 +43,7 @@ local_scheme = "no-local-version"
 dev = [
   "awscli",
   "build",
+  "docker",
   "lark",
   "pyre-check",
   "pytest",

{artefacts_cli-0.6.13 → artefacts_cli-0.6.17}/pytest.ini

@@ -1,5 +1,5 @@
 [pytest]
-addopts = -ra --quiet --cov-config .coveragerc --cov-report term-missing --cov-fail-under 25
+addopts = -ra --cov-config .coveragerc --cov-report term-missing --cov-fail-under 25
 console_output_style = progress
 env =
     ARTEFACTS_CLI_ENV=test

artefacts_cli-0.6.17/tests/cli/test_app_containers.py

@@ -0,0 +1,54 @@
+import os
+from uuid import uuid4
+
+import pytest
+
+from artefacts.cli.app_containers import containers
+
+
+def test_container_package_exists(cli_runner):
+    result = cli_runner.invoke(containers, [])
+    assert result.exit_code == 0
+
+
+def test_container_package_build_specific_dockerfile(
+    cli_runner, dockerfile_available, docker_mocker
+):
+    dockerfile = "non_standard_dockerfile"
+    result = cli_runner.invoke(containers, ["build", "--dockerfile", dockerfile])
+    dockerfile_available.assert_any_call(os.path.join(".", dockerfile))
+    assert result.exit_code == 0
+
+
+def test_container_package_build_specific_dockerfile_missing(
+    cli_runner, dockerfile_not_available
+):
+    dockerfile = "non_standard_dockerfile"
+    result = cli_runner.invoke(containers, ["build", "--dockerfile", dockerfile])
+    dockerfile_not_available.assert_any_call(os.path.join(".", dockerfile))
+    assert result.exit_code == 1
+    assert (
+        result.output.strip()
+        == f"Error: No {dockerfile} found here. I cannot build the container."
+    )
+
+
+def test_container_package_build_specific_image_name(
+    cli_runner, dockerfile_available, docker_mocker
+):
+    name = str(uuid4())
+    before = len(docker_mocker.images())
+    result = cli_runner.invoke(containers, ["build", "--name", name])
+    assert result.exit_code == 0
+    assert len(docker_mocker.images()) == before + 1
+    assert docker_mocker.get_image(name).Repository == name
+
+
+def test_container_package_build_default_image_name(
+    cli_runner, dockerfile_available, docker_mocker
+):
+    before = len(docker_mocker.images())
+    result = cli_runner.invoke(containers, ["build"])
+    assert result.exit_code == 0
+    assert len(docker_mocker.images()) == before + 1
+    assert docker_mocker.get_image("artefacts") is not None

artefacts_cli-0.6.17/tests/conftest.py

@@ -0,0 +1,42 @@
+import pytest
+
+import os
+
+from click.testing import CliRunner
+import docker
+
+from tests.utils import docker_mock
+
+
+def dockerfile_presence(mocker, value: bool):
+    original = os.path.exists
+
+    def exists(path):
+        if "dockerfile" in path.lower():
+            return value
+        else:
+            return original(path)
+
+    return mocker.patch("os.path.exists", side_effect=exists, autospec=True)
+
+
+@pytest.fixture(scope="function")
+def dockerfile_available(mocker):
+    return dockerfile_presence(mocker, True)
+
+
+@pytest.fixture(scope="function")
+def dockerfile_not_available(mocker):
+    return dockerfile_presence(mocker, False)
+
+
+@pytest.fixture(scope="module")
+def docker_mocker(module_mocker):
+    test_client = docker_mock.make_fake_api_client()
+    module_mocker.patch("docker.APIClient", return_value=test_client)
+    return test_client
+
+
+@pytest.fixture(scope="module")
+def cli_runner():
+    return CliRunner()

artefacts_cli-0.6.17/tests/utils/docker_mock.py

@@ -0,0 +1,89 @@
+# Fake Docker client
+
+import copy
+from dataclasses import dataclass, asdict
+import hashlib
+from random import randint
+from unittest import mock
+
+from docker import DockerClient, APIClient
+from docker.constants import DEFAULT_DOCKER_API_VERSION
+
+
+@dataclass
+class SimpleImage:
+    Id: str
+    Created: str
+    Repository: str
+    RepoTags: list
+
+
+class TestDockerAPIClient(APIClient):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.fake_server_db = {}
+        self.fake_image_id_base = hashlib.new("sha256")
+
+    def build(self, *args, **kwargs):
+        if kwargs["tag"] in self.fake_server_db:
+            original = self.fake_server_db[kwargs["tag"]]
+            for img in original:
+                # Mimick what Docker seems to be doing
+                img.Repository = ""
+                img.RepoTags = []
+        else:
+            original = []
+
+        # Generate a random yet compliant image ID
+        # Note the use of update, to ensure calling many times will be on different input (so unique IDs).
+        self.fake_image_id_base.update(bytes(randint(0, 100)))
+        iid = "sha256:" + self.fake_image_id_base.hexdigest()
+
+        new_collection = [
+            SimpleImage(
+                **{
+                    "Id": iid,
+                    "Created": "1 min ago",
+                    "Repository": kwargs["tag"],
+                    "RepoTags": [kwargs["tag"] + ":latest"],
+                }
+            )
+        ]
+        # Ensure the new entry is in the first place
+        new_collection.extend(original)
+        self.fake_server_db[kwargs["tag"]] = new_collection
+
+        return [b'"fake"', b'"test"', b'"logs"']
+
+    def images(self, *args, **kwargs):
+        if kwargs.get("name", None):
+            return self.fake_server_db.get(kwargs["name"])
+        else:
+            return [v for vs in self.fake_server_db.values() for v in vs]
+
+    def get_image(self, name):
+        # Index 0 is the latest
+        return self.fake_server_db.get(name)[0]
+
+    def inspect_image(self, name):
+        return asdict(self.get_image(name))
+
+
+class TestDockerClient(DockerClient):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.api = TestDockerAPIClient(version=kwargs["version"])
+
+
+def make_fake_api_client():
+    """
+    Incomplete fake API client.
+    """
+    return TestDockerAPIClient(version=DEFAULT_DOCKER_API_VERSION)
+
+
+def make_fake_client():
+    """
+    Test client with a fake API client.
+    """
+    return TestDockerClient(version=DEFAULT_DOCKER_API_VERSION)

artefacts_cli-0.6.13/artefacts/cli/utils.py

@@ -1,35 +0,0 @@
-import subprocess
-import sys
-
-
-def run_and_save_logs(
-    args, output_path, shell=False, executable=None, env=None, cwd=None
-):
-    """
-    Run a command and save stdout and stderr to a file in output_path
-
-    Note: explicitly list used named params instead of using **kwargs to avoid typing issue: https://github.com/microsoft/pyright/issues/455#issuecomment-780076232
-    """
-    output_file = open(output_path, "wb")
-    proc = subprocess.Popen(
-        args,
-        stdout=subprocess.PIPE,  # Capture stdout
-        stderr=subprocess.PIPE,  # Capture stderr
-        shell=shell,
-        executable=executable,
-        env=env,
-        cwd=cwd,
-    )
-    # write test-process stdout and stderr into file and stdout
-    if proc.stdout:
-        for line in proc.stdout:
-            decoded_line = line.decode()
-            sys.stdout.write(decoded_line)
-            output_file.write(line)
-    if proc.stderr:
-        for line in proc.stderr:
-            decoded_line = line.decode()
-            sys.stderr.write(decoded_line)
-            output_file.write(line)
-    proc.wait()
-    return proc.returncode

artefacts_cli-0.6.13/tests/conftest.py

@@ -1,8 +0,0 @@
-import pytest
-
-from click.testing import CliRunner
-
-
-@pytest.fixture(scope="module")
-def cli_runner():
-    return CliRunner()