pycompss-cli 3.3.6__py3-none-any.whl

pycompss_cli/cli/pycompss.py

@@ -0,0 +1,49 @@
+#!/usr/bin/env python3
+#
+#  Copyright 2002-2025 Barcelona Supercomputing Center (www.bsc.es)
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+
+from pycompss_cli.core.arguments import parse_sys_argv
+from pycompss_cli.core.actions_dispatcher import ActionsDispatcher
+import sys
+
+# Globals
+LINE_LENGTH = 79
+LINE = "-" * LINE_LENGTH
+
+
+def main():
+    """
+    MAIN ENTRY POINT
+    """        
+    
+    arguments = parse_sys_argv()
+
+    if arguments.debug:
+        print(LINE)
+        
+        if 'enqueue_args' in arguments:
+            del arguments.enqueue_args
+        if 'runcompss_args' in arguments:
+            del arguments.runcompss_args
+        print("Calling pycompss-cli for action: " + arguments.action)
+        print()
+        print("Arguments: " + str(arguments))
+
+    ActionsDispatcher().run_action(arguments)
+
+
+if __name__ == "__main__":
+    main()

pycompss_cli/core/__init__.py

@@ -0,0 +1,16 @@
+#!/usr/bin/env python3
+#
+#  Copyright 2002-2025 Barcelona Supercomputing Center (www.bsc.es)
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#

pycompss_cli/core/actions.py

@@ -0,0 +1,173 @@
+#!/usr/bin/env python3
+#
+#  Copyright 2002-2025 Barcelona Supercomputing Center (www.bsc.es)
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+"""
+This file contains the actions supported by pycompss-cli.
+They are invoked from cli/pycompss.py and uses core/cmd.py.
+"""
+from abc import ABC, abstractmethod
+import json
+import os
+import shutil
+from pathlib import Path
+from glob import glob
+from pycompss_cli.core import utils
+from uuid import uuid4 as uuid
+
+class Actions(ABC):
+
+    def __init__(self, arguments, debug=False, env_conf=None) -> None:
+        super().__init__()
+        self.arguments = arguments
+        self.debug = debug
+        self.env_conf = env_conf
+        self.home_path = str(Path.home())
+
+        if self.env_conf:
+            self.env_conf['env_path'] = self.home_path + '/.COMPSs/envs/' + self.env_conf['name']
+
+        if 'name' in self.arguments and self.arguments.name == 'unique uuid':
+            self.arguments.name = ''.join(str(uuid()).split('-')[:2])
+
+
+    def env_add_conf(self, extra_conf):
+        current_env, env_conf_path = utils.get_current_env_conf(env_id=self.arguments.name, return_path=True)
+        new_conf =  {**current_env, **extra_conf}
+        with open(env_conf_path, 'w') as f:
+            json.dump(new_conf, f)
+
+
+    @abstractmethod
+    def init(self):
+        if not self.arguments.env:
+            self.arguments.func()
+            exit(0)
+
+        del self.arguments.func
+
+        if os.path.isdir(self.home_path + '/.COMPSs/envs'):
+            envs = os.listdir(self.home_path + '/.COMPSs/envs')
+
+            if self.arguments.name in envs:
+                print("ERROR: There's already another environment named " + self.arguments.name)
+                exit(1)
+
+        env_path = self.home_path + '/.COMPSs/envs/' + self.arguments.name
+        self.arguments.env_path = env_path
+
+        os.makedirs(env_path)
+
+        with open(env_path + '/env.json', 'w') as env_conf:
+            json.dump(vars(self.arguments), env_conf)
+        self.env_conf = vars(self.arguments)
+
+        if self.arguments.config:
+            shutil.copy2(self.arguments.config, env_path)
+
+        print('Environment created ID:', self.arguments.name)
+
+    @abstractmethod
+    def exec(self):
+        pass
+
+    @abstractmethod
+    def run(self):
+        pass
+
+    @abstractmethod
+    def job(self):
+        if not self.arguments.job:
+            self.arguments.func()
+            exit(0)
+
+    def job_submit(self):
+        if not self.arguments.rest_args:
+            print(self.arguments.enqueue_args)
+            exit(0)
+
+    @abstractmethod
+    def app(self):
+        raise NotImplementedError("Wrong Environment! Try switching to a `remote` environment")
+
+    @abstractmethod
+    def jupyter(self):
+        pass
+
+    @abstractmethod
+    def monitor(self):
+        pass
+
+    @abstractmethod
+    def gengraph(self):
+        pass
+
+    @abstractmethod
+    def gentrace(self):
+        pass
+
+    @abstractmethod
+    def components(self):
+        pass
+
+    def environment(self):
+        action_name = 'list'
+
+        if self.arguments.environment:
+            action_name = self.arguments.environment
+
+        action_name = utils.get_object_method_by_name(self, 'env_' + action_name, include_in_name=True)
+        getattr(self, action_name)()
+
+    def env_list(self):
+        envs_path = self.home_path + '/.COMPSs/envs'
+        envs_files = os.listdir(envs_path)
+
+        env_info = []
+        for env_name in envs_files:
+            env_type = json.load(open(envs_path + f'/{env_name}/env.json'))['env']
+            env_current = '*' if 'current' in os.listdir(envs_path + f'/{env_name}') else ''
+            env_info.append([env_name, env_type, env_current])
+
+        col_names = ['ID', 'Type', 'Active']
+        utils.table_print(col_names, env_info)
+
+
+    def env_change(self, env_id=None):
+        env_id = self.arguments.env_id if env_id is None else env_id
+        if not os.path.isdir(self.home_path + '/.COMPSs/envs/' + env_id):
+            print("ERROR: There's no environment named " + env_id)
+            exit(1)
+
+        current_files = glob(self.home_path + '/.COMPSs/envs/*/current')
+        if current_files:
+            os.remove(current_files[0])
+        env_dir_name = self.home_path + '/.COMPSs/envs/' + env_id
+        open(env_dir_name + '/current', 'a').close()
+        print(f'Environment `{env_id}` is now active')
+
+    @abstractmethod
+    def env_remove(self, eid=None):
+        self.env_change(env_id='default')
+        env_id = self.arguments.env_id if eid is None else eid
+
+        env_dir_name = self.home_path + '/.COMPSs/envs/' + env_id
+
+        print(f'Deleting environment `{env_id}`...')
+        shutil.rmtree(env_dir_name)
+
+    @abstractmethod
+    def inspect(self):
+        pass

pycompss_cli/core/actions_dispatcher.py

@@ -0,0 +1,113 @@
+#!/usr/bin/env python3
+#
+#  Copyright 2002-2025 Barcelona Supercomputing Center (www.bsc.es)
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+from pycompss_cli.core import utils
+from pycompss_cli.core.cmd_helpers import command_runner
+from copy import deepcopy
+import os
+from pathlib import Path
+import json
+
+class ActionsDispatcher(object):
+    def __init__(self) -> None:
+        super().__init__()
+        self.home_path = str(Path.home())
+
+    def run_action(self, arguments):
+        self.__ensure_default_env()
+
+        if arguments.version:
+            exit_code = command_runner(["runcompss", "-v"], silent=True)
+            exit(exit_code)
+
+        if 'env' in arguments and arguments.env:
+            env_type = arguments.env
+            env_conf = None
+        else:
+            envs_path = self.home_path + '/.COMPSs/envs'
+            if not os.path.isdir(envs_path) or len(list(os.walk(envs_path))) == 1:
+                print("There are no environments created. Try using `pycompss init`")
+                exit(1)
+
+            if arguments.action == 'environment':
+                if arguments.environment and arguments.environment.startswith('r'):
+                    self.__delete_envs(arguments.env_id, arguments)
+
+            env_id = arguments.env_id if arguments.env_id else None
+
+            env_conf = utils.get_current_env_conf(env_id=env_id)
+            env_type = env_conf['env']
+
+        self.__actions_cmd = self.__getactions_cmd(env_type, arguments, env_conf)
+
+        action_name = utils.get_object_method_by_name(self.__actions_cmd, arguments.action)
+        action_func = getattr(self.__actions_cmd, action_name)
+        action_func()
+
+    def __delete_envs(self, envs_ids, arguments):
+        for env_id in envs_ids:
+            env_type = self.__get_env_type_from_name(env_id)
+            if env_type is None:
+                print("ERROR: There's no environment named " + env_id)
+                continue
+            if env_id == 'default':
+                print('ERROR: `default` environment is required and cannot be deleted')
+                continue
+            env_conf = utils.get_env_conf_by_name(env_id)
+            env_arguments = deepcopy(arguments)
+            env_arguments.env_id = env_id
+            action_cmd = self.__getactions_cmd(env_type, env_arguments, env_conf=env_conf)
+            action_cmd.env_remove()
+        exit(0)
+
+    def __get_env_type_from_name(self, env_name):
+        envs_path = self.home_path + '/.COMPSs/envs'
+        env_dir_tree = list(os.walk(envs_path))
+        envs_names = env_dir_tree[0][1]
+        env_dir_tree = env_dir_tree[1:]
+        for i in range(len(env_dir_tree)):
+            if env_name == envs_names[i]:
+                return json.load(open(env_dir_tree[i][0] + '/env.json'))['env']
+        return None
+
+    def __getactions_cmd(self, env_type, arguments, env_conf=None):
+        debug = arguments.debug
+
+        if env_type == "local":
+            from pycompss_cli.core.local.actions import LocalActions
+            return LocalActions(arguments, debug, env_conf)
+        elif env_type == "docker":
+            from pycompss_cli.core.docker.actions import DockerActions
+            return DockerActions(arguments, debug, env_conf)
+        elif env_type == "remote":
+            from pycompss_cli.core.remote.actions import RemoteActions
+            return RemoteActions(arguments, debug, env_conf)
+        elif env_type == "unicore":
+            from pycompss_cli.core.unicore.actions import UnicoreActions
+            return UnicoreActions(arguments, debug, env_conf)
+        else:
+            raise NotImplementedError(f"Environment `{env_type}` not implemented")
+
+
+    def __ensure_default_env(self):
+        default_env = self.home_path + '/.COMPSs/envs/default'
+        if not os.path.isdir(default_env):
+            os.makedirs(default_env)
+            open(default_env + '/current', 'a').close()
+            with open(default_env + '/env.json', 'w') as def_env:
+                json.dump({ 'env': 'local', 'name': 'default' }, def_env)
+            with open(default_env + '/modules.sh', 'w') as mod_file:
+                mod_file.write('module load COMPSS')

pycompss_cli/core/arguments.py

@@ -0,0 +1,313 @@
+#!/usr/bin/env python3
+#
+#  Copyright 2002-2025 Barcelona Supercomputing Center (www.bsc.es)
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+import os
+import sys
+import argparse
+import subprocess
+
+from pycompss_cli.core.docker.arguments import docker_init_parser
+from pycompss_cli.core.local.arguments import local_init_parser
+from pycompss_cli.core.remote.arguments import remote_init_parser
+from pycompss_cli.core.remote.arguments import remote_parser_job
+from pycompss_cli.core.remote.arguments import remote_parser_app
+from pycompss_cli.core.unicore.arguments import unicore_init_parser
+from pycompss_cli.core import utils
+
+FORMATTER_CLASS = argparse.RawTextHelpFormatter
+
+def parse_sys_argv():
+    """ Parses the sys.argv.
+
+    :returns: All arguments as namespace.
+    """
+    parser = argparse.ArgumentParser(formatter_class=FORMATTER_CLASS)
+    parser.add_argument("-d", "--debug",
+                        help="Enable debug mode. Overrides log_level",
+                        action="store_true")
+
+    parser.add_argument("-eid", "--env_id",
+                             default="",
+                             type=str,
+                             help="Environment ID")
+    parser.add_argument("-v", "--version",
+                        help="Get version",
+                        action="store_true")
+
+    # Parent parser - includes all arguments which are common to all actions
+    parent_parser = argparse.ArgumentParser(add_help=False,
+                                            formatter_class=FORMATTER_CLASS)
+    # Action sub-parser
+    subparsers = parser.add_subparsers(dest="action")
+    # INIT
+    parser_init = subparsers.add_parser("init",
+                                        aliases=["i"],
+                                        help="Initialize COMPSs environment (default local).",
+                                        parents=[parent_parser],
+                                        formatter_class=FORMATTER_CLASS)
+
+    parser_init.set_defaults(func=lambda: print(parser_init.format_help()))
+
+    parser_init.add_argument("-cfg", "--config",
+                             default="",
+                             type=str,
+                             help="Configuration file")
+
+    parser_init.add_argument("-n", "--name",
+                             default='unique uuid',
+                             type=str,
+                             help="Environment name")
+
+    init_env_subparser = parser_init.add_subparsers(title="environment", dest="env")
+    # init_env_subparser.default = "local"
+
+    init_env_subparser.add_parser("docker", add_help=False,
+                                    parents=[docker_init_parser()])
+
+    init_env_subparser.add_parser("local", add_help=False,
+                                    parents=[local_init_parser()])
+
+    init_env_subparser.add_parser("remote", add_help=False,
+                                    parents=[remote_init_parser()])
+
+    init_env_subparser.add_parser("unicore", add_help=False,
+                                    parents=[unicore_init_parser()])
+
+    # EXEC
+    parser_exec = subparsers.add_parser("exec",
+                                        aliases=["ex"],
+                                        help="Execute the given command within the COMPSs\' environment.",  # noqa: E501
+                                        parents=[parent_parser],
+                                        formatter_class=FORMATTER_CLASS)
+    parser_exec.set_defaults(action='exec')
+
+
+    parser_exec.add_argument('exec_cmd',
+                            nargs=argparse.REMAINDER,
+                            help="Exec program arguments")
+    # RUN
+    parser_run = subparsers.add_parser("run",
+                                       aliases=["r"],
+                                       help="Run the application (with runcompss) within the COMPSs\' environment.",  # noqa: E501
+                                       parents=[parent_parser],
+                                       formatter_class=FORMATTER_CLASS)
+    parser_run.set_defaults(action='run')
+
+    if utils.check_exit_code('runcompss -h') == 0:
+        parser_run.epilog = subprocess.check_output('runcompss -h', shell=True).decode()
+    else:
+        assets_folder = os.path.dirname(os.path.abspath(__file__)) + '/..'
+        with open(assets_folder + '/assets/runcompss_args.txt', 'r', encoding='utf-8') as f:
+            parser_run.epilog = f.read()
+
+
+    parser_run.add_argument("-app", "--app_name",
+                             default="",
+                             type=str,
+                             help="Name of the app where to execute runcompss. Only required for `remote` type environment")
+    parser_run.add_argument('rest_args',
+                            nargs=argparse.REMAINDER,
+                            help="Runcompss program arguments")
+
+    # APP  remote_parser_app
+    parser_app = subparsers.add_parser("app", aliases=["a"], add_help=False,
+                                    help="Manage applications within remote environments.",  # noqa: E501
+                                    parents=[remote_parser_app()],
+                                    formatter_class=FORMATTER_CLASS)
+    parser_app.set_defaults(action='app')
+
+
+    # JOB
+    parser_job = subparsers.add_parser("job", aliases=["j"], add_help=False,
+                                    help="Manage jobs within remote environments.",  # noqa: E501
+                                    parents=[remote_parser_job()],
+                                    formatter_class=FORMATTER_CLASS)
+    parser_job.set_defaults(action='job')
+
+
+    # MONITOR
+    parser_monitor = subparsers.add_parser("monitor",
+                                           aliases=["m"],
+                                           help="Start the monitor within the COMPSs\' environment.",  # noqa: E501
+                                           parents=[parent_parser],
+                                           formatter_class=FORMATTER_CLASS)
+    parser_monitor.set_defaults(action='monitor')
+
+    parser_monitor.add_argument("option",
+                                help="Start or stop de monitoring service.",
+                                choices=["start", "stop"],
+                                default="start",
+                                type=str)
+
+    # JUPYTER
+    parser_jupyter = subparsers.add_parser("jupyter",
+                                           aliases=["jpy"],
+                                           help="Starts Jupyter within the COMPSs\' environment.",  # noqa: E501
+                                           parents=[parent_parser],
+                                           formatter_class=FORMATTER_CLASS)
+    parser_jupyter.set_defaults(action='jupyter')
+
+    parser_jupyter.add_argument("-lab",
+                             action="store_true",
+                             help="Run Jupyter Lab")
+
+
+    parser_jupyter.add_argument("-app", "--app_name",
+                             default="",
+                             type=str,
+                             help="Name of the app where the notebook will be deployed. Only required for `remote` type environment")
+    parser_jupyter.add_argument('rest_args',
+                            nargs=argparse.REMAINDER,
+                            help="Jupyter arguments")
+
+    # GENGRAPH
+    parser_gengraph = subparsers.add_parser("gengraph",
+                                            aliases=["gg"],
+                                            help="Converts the given graph into pdf.",  # noqa: E501
+                                            parents=[parent_parser],
+                                            formatter_class=FORMATTER_CLASS)
+    parser_gengraph.set_defaults(action='gengraph')
+
+    parser_gengraph.add_argument("dot_file",
+                                 type=str,
+                                 help="Dot file to convert to pdf")
+
+
+    # GENTRACE
+    parser_gentrace = subparsers.add_parser("gentrace",
+                                            aliases=["gt"],
+                                            help="Merges traces from all nodes into a Paraver trace.",  # noqa: E501
+                                            parents=[parent_parser],
+                                            formatter_class=FORMATTER_CLASS)
+    parser_gentrace.set_defaults(action='gentrace')
+
+    parser_gentrace.add_argument("trace_dir",
+                                 type=str,
+                                 help="Directory where the traces are located.")
+
+    parser_gentrace.add_argument("--download_dir",
+                                    type=str,
+                                    help="Directory where the traces will be downloaded.")
+
+    parser_gentrace.add_argument('rest_args',
+                            nargs=argparse.REMAINDER,
+                            help="compss_gentrace arguments")
+
+    # COMPONENTS
+    parser_components = subparsers.add_parser("components",
+                                              aliases=["c"],
+                                              help="Manage infrastructure components.",  # noqa: E501
+                                              parents=[parent_parser],
+                                              formatter_class=FORMATTER_CLASS)
+    parser_components.set_defaults(action='components')
+
+
+    subparsers_components = parser_components.add_subparsers(dest="components")
+
+    subparsers_components.add_parser("list",
+                                    aliases=["l"],
+                                    help="List COMPSs active components.",  # noqa: E501
+                                    formatter_class=FORMATTER_CLASS)        # noqa: E501
+    parser_components_add = subparsers_components.add_parser("add",
+                                                             aliases=["a"],
+                                                             help="Adds the RESOURCE to the pool of workers of the COMPSs.",  # noqa: E501
+                                                             formatter_class=FORMATTER_CLASS)                                 # noqa: E501
+    subparsers_components_add = parser_components_add.add_subparsers(dest="add")                          # noqa: E501
+    parser_components_add_worker = subparsers_components_add.add_parser("worker",                         # noqa: E501
+                                                                        aliases=["w"],                    # noqa: E501
+                                                                        help="Add a worker.",             # noqa: E501
+                                                                        formatter_class=FORMATTER_CLASS)  # noqa: E501
+    parser_components_add_worker.add_argument("worker",
+                                              type=str,
+                                              default="1",
+                                              help="Number of workers to add (can be integer or <IP>:<CORES> to add remote workers).")  # noqa: E501
+    parser_components_remove = subparsers_components.add_parser("remove",
+                                                                aliases=["r"],
+                                                                help="Removes the RESOURCE to the pool of workers of the COMPSs.",  # noqa: E501
+                                                                formatter_class=FORMATTER_CLASS)                                    # noqa: E501
+    subparsers_components_remove = parser_components_remove.add_subparsers(dest="remove")                                           # noqa: E501
+    parser_components_remove_worker = subparsers_components_remove.add_parser("worker",                                             # noqa: E501
+                                                                              aliases=["w"],                                        # noqa: E501
+                                                                              help="Remove a worker.",                              # noqa: E501
+                                                                              formatter_class=FORMATTER_CLASS)                      # noqa: E501
+    parser_components_remove_worker.add_argument("worker",
+                                                 type=str,
+                                                 default="1",
+                                                 help="Number of workers to remove (can be integer or <IP>:<CORES> to add remote workers).")  # noqa: E501
+
+
+    # ENVIRONMENT
+    parser_environment = subparsers.add_parser("environment",
+                                              aliases=["env"],
+                                              help="Manage COMPSs environments.",  # noqa: E501
+                                              parents=[parent_parser],
+                                              formatter_class=FORMATTER_CLASS)
+
+    parser_environment.set_defaults(action='environment')
+
+    subparsers_environment = parser_environment.add_subparsers(dest="environment")
+
+    subparsers_environment.add_parser("list",
+                                        aliases=["l"],
+                                        help="List COMPSs active environments.",  # noqa: E501
+                                        formatter_class=FORMATTER_CLASS)        # noqa: E501
+    parser_environment_change = subparsers_environment.add_parser("change",
+                                                             aliases=["c"],
+                                                             help="Change current COMPSs environment.",  # noqa: E501
+                                                             formatter_class=FORMATTER_CLASS)
+    parser_environment_change.add_argument("env_id",
+                                            type=str,
+                                            help="ID of the environment to set as active")  # noqa: E501
+
+    parser_environment_remove = subparsers_environment.add_parser("remove",
+                                                                aliases=["r"],
+                                                                help="Removes COMPSs environment.",  # noqa: E501
+                                                                formatter_class=FORMATTER_CLASS)                  # noqa: E501
+
+    parser_environment_remove.add_argument("-f", "--force",
+                             action='store_true',
+                             default=False,
+                             help="Force deleting de environment and the applications")
+
+    parser_environment_remove.add_argument("env_id",
+                                            nargs="+",
+                                            type=str,
+                                            help="ID of the environment to remove")  # noqa: E501
+
+    # INSPECT
+    parser_environment = subparsers.add_parser("inspect",
+                                               aliases=["ins"],
+                                               help="Inspect RO-Crate(s) from a COMPSs application run.",  # noqa: E501
+                                               parents=[parent_parser],
+                                               formatter_class=FORMATTER_CLASS)
+
+    parser_environment.set_defaults(action='inspect')
+
+    parser_environment.add_argument("ro_crate",
+                                 type=str,
+                                 nargs='+',
+                                 help="Folder or zip file(s) containing the RO-Crate(s)")
+
+    # Check if the user does not include any argument
+    if len(sys.argv) < 2:
+        print(parser.print_help())
+        sys.exit(1)
+
+    arguments, leftovers = parser.parse_known_args()
+    if leftovers:
+        arguments.rest_args = leftovers + arguments.rest_args
+
+    return arguments