elapi 1.0.7.dev7__py3-none-any.whl → 2.0.0__py3-none-any.whl

elapi/VERSION

@@ -1 +1 @@
-1.0.7.dev7
+2.0.0

elapi/_names.py

@@ -5,8 +5,10 @@ from pathlib import Path
 # In which case, import their counterparts from src/config.py
 # name definitions
 APP_NAME: str = "elapi"
+APP_BRAND_NAME: str = "elAPI"
 LOG_FILE_NAME: str = f"{APP_NAME}.log"
-CONFIG_FILE_NAME: str = f"{APP_NAME}.yml"
+CONFIG_FILE_EXTENSION: str = "yml"
+CONFIG_FILE_NAME: str = f"{APP_NAME}.{CONFIG_FILE_EXTENSION}"
 DEFAULT_EXPORT_DATA_FORMAT: str = "json"
 user_home: Path = Path.home()
 cur_dir: Path = Path.cwd()
@@ -41,6 +43,7 @@ KEY_UNSAFE_TOKEN_WARNING: str = "UNSAFE_API_TOKEN_WARNING"
 KEY_ENABLE_HTTP2: str = "ENABLE_HTTP2"
 KEY_VERIFY_SSL: str = "VERIFY_SSL"
 KEY_TIMEOUT: str = "TIMEOUT"
+KEY_DEVELOPMENT_MODE: str = "DEVELOPMENT_MODE"
 
 # Log data directory with root permission
 LOG_DIR_ROOT: Path = Path(f"/var/log/{APP_NAME}")

elapi/api/api.py

@@ -5,6 +5,7 @@ from typing import Union, Optional, Tuple
 from httpx import Response, Client, AsyncClient, Limits
 from httpx_auth import HeaderApiKey
 
+from .. import APP_NAME
 from ..configuration import (
     TOKEN_BEARER,
     get_active_host,
@@ -19,6 +20,9 @@ class APIRequest(ABC):
     __slots__ = "keep_session_open", "_client", "host", "api_token", "header_name"
 
     def __init__(self, keep_session_open: bool = False, **kwargs):
+        from ..utils import check_reserved_keyword
+        from .._names import CONFIG_FILE_NAME
+
         self.host: str = get_active_host()
         self.api_token: str = get_active_api_token().token
         self.header_name: str = TOKEN_BEARER
@@ -27,13 +31,23 @@ class APIRequest(ABC):
         verify_ssl = get_active_verify_ssl()
         timeout = get_active_timeout()
         _client = Client if not self.is_async_client else AsyncClient
-        self._client: Union[Client, AsyncClient] = _client(
-            auth=HeaderApiKey(api_key=self.api_token, header_name=self.header_name),
-            http2=enable_http2,
-            verify=verify_ssl,
-            timeout=timeout,
-            **kwargs,
-        )
+        try:
+            self._client: Union[Client, AsyncClient] = _client(
+                auth=HeaderApiKey(api_key=self.api_token, header_name=self.header_name),
+                http2=enable_http2,
+                verify=verify_ssl,
+                timeout=timeout,
+                **kwargs,
+            )
+        except TypeError as e:
+            check_reserved_keyword(
+                e,
+                what=f"{APP_NAME}",
+                against=f"abstract class {APIRequest.__name__}, "
+                f"so the parameter remains user-configurable "
+                f"through {CONFIG_FILE_NAME} configuration file",
+            )
+            raise e
 
     # noinspection PyMethodOverriding
     def __init_subclass__(cls, /, is_async_client: bool = False, **kwargs):

elapi/cli/_plugin_handler.py

@@ -1,17 +1,30 @@
 import importlib.util
 import sys
+from collections import namedtuple
 from pathlib import Path
-from typing import List, Tuple, Generator
+from typing import List, Tuple, Generator, Union, Optional
 
 import typer
 
+from ..configuration import get_development_mode
 from ..configuration.config import (
     ROOT_INSTALLATION_DIR,
     INTERNAL_PLUGIN_DIRECTORY_NAME,
     INTERNAL_PLUGIN_TYPER_APP_FILE_NAME_PREFIX,
     INTERNAL_PLUGIN_TYPER_APP_FILE_NAME,
     INTERNAL_PLUGIN_TYPER_APP_VAR_NAME,
+    EXTERNAL_LOCAL_PLUGIN_DIRECTORY_NAME,
+    EXTERNAL_LOCAL_PLUGIN_DIR,
+    EXTERNAL_LOCAL_PLUGIN_TYPER_APP_FILE_NAME_PREFIX,
+    EXTERNAL_LOCAL_PLUGIN_TYPER_APP_VAR_NAME,
 )
+from ..core_validators import Validator, ValidationError, Validate
+from ..loggers import Logger
+from ..path import ProperPath
+from ..utils import add_message
+
+logger = Logger()
+PluginInfo = namedtuple("PluginInfo", ["plugin_app", "path", "venv"])
 
 
 class InternalPluginHandler:
@@ -44,4 +57,335 @@ class InternalPluginHandler:
                 yield
 
 
+class ExternalPluginLocationValidator(Validator):
+    def __init__(self, location: Union[str, Path, ProperPath], /):
+        self.location = location
+
+    @property
+    def location(self):
+        return self._location
+
+    @location.setter
+    def location(self, value):
+        if not isinstance(value, ProperPath):
+            try:
+                value = ProperPath(value)
+            except ValueError as e:
+                raise ValueError(
+                    f"'location' attribute for class {self.__class__.__class__} "
+                    f"is invalid."
+                ) from e
+            else:
+                self._location = value.expanded
+
+    def validate(self):
+        import os
+        import yaml
+        from ..configuration import (
+            EXTERNAL_LOCAL_PLUGIN_METADATA_FILE_NAME,
+            EXTERNAL_LOCAL_PLUGIN_TYPER_APP_FILE_NAME,
+            EXTERNAL_LOCAL_PLUGIN_METADATA_FILE_KEY_FILE_EXISTS,
+            EXTERNAL_LOCAL_PLUGIN_METADATA_FILE_KEY_CLI_SCRIPT_PATH,
+            EXTERNAL_LOCAL_PLUGIN_METADATA_FILE_KEY_VENV_PATH,
+            EXTERNAL_LOCAL_PLUGIN_METADATA_FILE_KEY_PLUGIN_NAME,
+            CANON_YAML_EXTENSION,
+        )
+
+        parsed_metadata: dict = {
+            EXTERNAL_LOCAL_PLUGIN_METADATA_FILE_KEY_FILE_EXISTS: None,
+            EXTERNAL_LOCAL_PLUGIN_METADATA_FILE_KEY_CLI_SCRIPT_PATH: None,
+            # EXTERNAL_LOCAL_PLUGIN_METADATA_FILE_KEY_VENV_PATH: None,
+            EXTERNAL_LOCAL_PLUGIN_METADATA_FILE_KEY_PLUGIN_NAME: None,
+        }
+
+        if self.location.is_dir():
+            actual_cwd = Path.cwd()
+            os.chdir(self.location)
+            if (
+                plugin_metadata_file := (
+                    self.location / EXTERNAL_LOCAL_PLUGIN_METADATA_FILE_NAME
+                )
+            ).exists():
+                parsed_metadata[EXTERNAL_LOCAL_PLUGIN_METADATA_FILE_KEY_FILE_EXISTS] = (
+                    True
+                )
+                with ProperPath(plugin_metadata_file).open(mode="r") as f:
+                    try:
+                        plugin_metadata = yaml.safe_load(f)
+                    except yaml.YAMLError as e:
+                        raise ValidationError(
+                            f"Plugin {CANON_YAML_EXTENSION.upper()} "
+                            f"metadata file {plugin_metadata_file} exists, "
+                            f"but it couldn't be parsed. Exception details: {e}"
+                        )
+                    else:
+                        try:
+                            CLI_SCRIPT_PATH = plugin_metadata[
+                                EXTERNAL_LOCAL_PLUGIN_METADATA_FILE_KEY_CLI_SCRIPT_PATH
+                            ]
+                        except KeyError:
+                            if (
+                                external_local_plugin_typer_app_file := (
+                                    self.location
+                                    / EXTERNAL_LOCAL_PLUGIN_TYPER_APP_FILE_NAME
+                                )
+                            ).exists():
+                                parsed_metadata[
+                                    EXTERNAL_LOCAL_PLUGIN_METADATA_FILE_KEY_CLI_SCRIPT_PATH
+                                ] = external_local_plugin_typer_app_file
+                        else:
+                            try:
+                                CLI_SCRIPT_PATH = ProperPath(CLI_SCRIPT_PATH)
+                            except ValueError:
+                                raise ValidationError(
+                                    f"Key '{EXTERNAL_LOCAL_PLUGIN_METADATA_FILE_KEY_CLI_SCRIPT_PATH}' "
+                                    f"exists in {plugin_metadata_file}, but its assigned "
+                                    f"value '{CLI_SCRIPT_PATH}' is invalid."
+                                )
+                            else:
+                                if CLI_SCRIPT_PATH.expanded.exists():
+                                    parsed_metadata[
+                                        EXTERNAL_LOCAL_PLUGIN_METADATA_FILE_KEY_CLI_SCRIPT_PATH
+                                    ] = CLI_SCRIPT_PATH.expanded.absolute()
+                                else:
+                                    raise ValidationError(
+                                        f"Key '{EXTERNAL_LOCAL_PLUGIN_METADATA_FILE_KEY_CLI_SCRIPT_PATH}' "
+                                        f"exists in {plugin_metadata_file}, but the path "
+                                        f"{CLI_SCRIPT_PATH} does not exist."
+                                    )
+                        try:
+                            VENV_PATH = plugin_metadata[
+                                EXTERNAL_LOCAL_PLUGIN_METADATA_FILE_KEY_VENV_PATH
+                            ]
+                        except KeyError:
+                            VENV_PATH = parsed_metadata[
+                                EXTERNAL_LOCAL_PLUGIN_METADATA_FILE_KEY_VENV_PATH
+                            ] = None
+                        else:
+                            try:
+                                VENV_PATH = ProperPath(VENV_PATH)
+                            except ValueError:
+                                raise ValidationError(
+                                    f"Key '{EXTERNAL_LOCAL_PLUGIN_METADATA_FILE_KEY_VENV_PATH}' "
+                                    f"exists in {plugin_metadata_file}, but its assigned "
+                                    f"value '{VENV_PATH}' is invalid."
+                                )
+                            else:
+                                if VENV_PATH.expanded.exists():
+                                    parsed_metadata[
+                                        EXTERNAL_LOCAL_PLUGIN_METADATA_FILE_KEY_VENV_PATH
+                                    ] = VENV_PATH.expanded.absolute()
+                                else:
+                                    raise ValidationError(
+                                        f"Key '{EXTERNAL_LOCAL_PLUGIN_METADATA_FILE_KEY_VENV_PATH}' "
+                                        f"exists in {plugin_metadata_file}, but the path "
+                                        f"{VENV_PATH} does not exist."
+                                    )
+                        try:
+                            PLUGIN_NAME = plugin_metadata[
+                                EXTERNAL_LOCAL_PLUGIN_METADATA_FILE_KEY_PLUGIN_NAME
+                            ]
+                        except KeyError:
+                            PLUGIN_NAME = parsed_metadata[
+                                EXTERNAL_LOCAL_PLUGIN_METADATA_FILE_KEY_PLUGIN_NAME
+                            ] = self.location.name
+                        else:
+                            if self.location.name != PLUGIN_NAME:
+                                raise ValidationError(
+                                    f"Key '{EXTERNAL_LOCAL_PLUGIN_METADATA_FILE_KEY_PLUGIN_NAME}' "
+                                    f"exists in {plugin_metadata_file}, but it must be the same "
+                                    f"name as the directory name the metadata file is in."
+                                )
+                            parsed_metadata[
+                                EXTERNAL_LOCAL_PLUGIN_METADATA_FILE_KEY_PLUGIN_NAME
+                            ] = PLUGIN_NAME
+            else:
+                parsed_metadata[EXTERNAL_LOCAL_PLUGIN_METADATA_FILE_KEY_FILE_EXISTS] = (
+                    False
+                )
+                if (
+                    external_local_plugin_typer_app_file := (
+                        self.location / EXTERNAL_LOCAL_PLUGIN_TYPER_APP_FILE_NAME
+                    )
+                ).exists():
+                    parsed_metadata[
+                        EXTERNAL_LOCAL_PLUGIN_METADATA_FILE_KEY_CLI_SCRIPT_PATH
+                    ] = external_local_plugin_typer_app_file
+                    PLUGIN_NAME = self.location.name
+                    parsed_metadata[
+                        EXTERNAL_LOCAL_PLUGIN_METADATA_FILE_KEY_PLUGIN_NAME
+                    ] = PLUGIN_NAME
+                else:
+                    raise ValueError(f"{self.location} may not be a plugin directory.")
+            os.chdir(actual_cwd)
+        else:
+            raise ValueError(f"{self.location} is not a directory.")
+        return parsed_metadata
+
+
+class ExternalPluginHandler:
+    @staticmethod
+    def get_plugin_metadata() -> Generator[Optional[dict], None, None]:
+        from ..utils import add_message
+        from ..configuration import EXTERNAL_LOCAL_PLUGIN_METADATA_KEY_PLUGIN_ROOT_DIR
+
+        try:
+            for path in sorted(
+                EXTERNAL_LOCAL_PLUGIN_DIR.iterdir(), key=lambda x: str(x).lower()
+            ):
+                try:
+                    metadata = Validate(ExternalPluginLocationValidator(path)).get()
+                except ValidationError as e:
+                    add_message(f"{e}")
+                    continue
+                except ValueError:
+                    continue
+                else:
+                    metadata[EXTERNAL_LOCAL_PLUGIN_METADATA_KEY_PLUGIN_ROOT_DIR] = path
+                    yield metadata
+        except FileNotFoundError:
+            yield None
+
+    @staticmethod
+    def load_plugin(plugin_name: str, cli_script: Path):
+        spec = importlib.util.spec_from_file_location(plugin_name, cli_script)
+        module = importlib.util.module_from_spec(spec)
+        sys.modules[spec.name] = module
+        module.__package__ = (
+            f"{__package__.removesuffix(f'.{EXTERNAL_LOCAL_PLUGIN_TYPER_APP_FILE_NAME_PREFIX}')}"
+            f".{EXTERNAL_LOCAL_PLUGIN_DIRECTORY_NAME}.{plugin_name}"
+        )  # Python will find module relative to __package__ path,
+        # without this module.__package__ change Python will throw an ImportError.
+        spec.loader.exec_module(module)
+        return module
+
+    def get_typer_apps(self) -> Generator[PluginInfo, None, None]:
+        import logging
+        from ..configuration import (
+            EXTERNAL_LOCAL_PLUGIN_METADATA_FILE_KEY_FILE_EXISTS,
+            EXTERNAL_LOCAL_PLUGIN_METADATA_FILE_KEY_CLI_SCRIPT_PATH,
+            EXTERNAL_LOCAL_PLUGIN_METADATA_FILE_KEY_PLUGIN_NAME,
+            EXTERNAL_LOCAL_PLUGIN_METADATA_KEY_PLUGIN_ROOT_DIR,
+            EXTERNAL_LOCAL_PLUGIN_METADATA_FILE_KEY_VENV_PATH,
+        )
+        from ._venv_state_manager import switch_venv_state
+
+        for metadata in self.get_plugin_metadata():
+            if metadata is None:
+                break
+            plugin_name: str = metadata[
+                EXTERNAL_LOCAL_PLUGIN_METADATA_FILE_KEY_PLUGIN_NAME
+            ]
+            cli_script: Path = metadata[
+                EXTERNAL_LOCAL_PLUGIN_METADATA_FILE_KEY_CLI_SCRIPT_PATH
+            ]
+            plugin_root_dir: Path = metadata[
+                EXTERNAL_LOCAL_PLUGIN_METADATA_KEY_PLUGIN_ROOT_DIR
+            ]
+            if metadata[EXTERNAL_LOCAL_PLUGIN_METADATA_FILE_KEY_FILE_EXISTS] is False:
+                try:
+                    module = self.load_plugin(plugin_name, cli_script)
+                except (Exception, BaseException) as e:
+                    if get_development_mode() is True:
+                        raise e
+                    message: str = (
+                        f"An exception occurred while trying to load a local "
+                        f"plugin '{plugin_name}' in path {cli_script}. "
+                        f"Plugin '{plugin_name}' will be ignored. "
+                        f'Exception details: "{e.__class__.__name__}: {e}"'
+                    )
+                    add_message(message, logging.WARNING)
+                    yield
+                else:
+                    try:
+                        typer_app: typer.Typer = getattr(
+                            module, EXTERNAL_LOCAL_PLUGIN_TYPER_APP_VAR_NAME
+                        )
+                    except AttributeError:
+                        yield
+                    else:
+                        typer_app.info.name = plugin_name
+                        yield PluginInfo(
+                            typer_app,
+                            plugin_root_dir,
+                            None,
+                        )
+            else:
+                venv_dir: Path = metadata[
+                    EXTERNAL_LOCAL_PLUGIN_METADATA_FILE_KEY_VENV_PATH
+                ]
+                if venv_dir is not None:
+                    try:
+                        switch_venv_state(True, venv_dir)
+                    except (ValueError, RuntimeError) as e:
+                        message: str = (
+                            f"An exception occurred while trying to load a local "
+                            f"plugin '{plugin_name}' with virtual environment {venv_dir} "
+                            f"in path {cli_script}. "
+                            f"Plugin '{plugin_name}' will be ignored. "
+                            f'Exception details: "{e.__class__.__name__}: {e}"'
+                        )
+                        add_message(message, logging.WARNING)
+                        yield
+                    else:
+                        try:
+                            module = self.load_plugin(plugin_name, cli_script)
+                        except (Exception, BaseException) as e:
+                            if get_development_mode() is True:
+                                raise e
+                            message: str = (
+                                f"An exception occurred while trying to load a local "
+                                f"plugin '{plugin_name}' with virtual environment {venv_dir} "
+                                f"in path {cli_script}. "
+                                f"Plugin '{plugin_name}' will be ignored. "
+                                f'Exception details: "{e.__class__.__name__}: {e}"'
+                            )
+                            add_message(message, logging.WARNING)
+                            yield
+                        else:
+                            try:
+                                typer_app: typer.Typer = getattr(
+                                    module, EXTERNAL_LOCAL_PLUGIN_TYPER_APP_VAR_NAME
+                                )
+                            except AttributeError:
+                                yield
+                            else:
+                                switch_venv_state(False, venv_dir)
+                                typer_app.info.name = plugin_name
+                                yield PluginInfo(
+                                    typer_app,
+                                    plugin_root_dir,
+                                    venv_dir,
+                                )
+                else:
+                    try:
+                        module = self.load_plugin(plugin_name, cli_script)
+                    except (Exception, BaseException) as e:
+                        if get_development_mode() is True:
+                            raise e
+                        message: str = (
+                            f"An exception occurred while trying to load a local "
+                            f"plugin '{plugin_name}' in path {cli_script}. "
+                            f"Plugin '{plugin_name}' will be ignored. "
+                            f'Exception details: "{e.__class__.__name__}: {e}"'
+                        )
+                        add_message(message, logging.WARNING)
+                        yield
+                    else:
+                        try:
+                            typer_app: typer.Typer = getattr(
+                                module, EXTERNAL_LOCAL_PLUGIN_TYPER_APP_VAR_NAME
+                            )
+                        except AttributeError:
+                            yield
+                        else:
+                            typer_app.info.name = plugin_name
+                            yield PluginInfo(
+                                typer_app,
+                                plugin_root_dir,
+                                None,
+                            )
+
+
 internal_plugin_typer_apps = InternalPluginHandler().get_typer_apps()
+external_local_plugin_typer_apps = ExternalPluginHandler().get_typer_apps()

elapi/cli/_venv_state_manager.py

@@ -0,0 +1,39 @@
+from pathlib import Path
+from typing import Union
+
+from ..path import ProperPath
+
+VENV_INDICATOR_DIR_NAME: str = "site-packages"
+
+
+def switch_venv_state(status: bool, /, venv_dir: Union[Path, ProperPath]):
+    import sys
+
+    site_packages = sorted(
+        venv_dir.rglob(VENV_INDICATOR_DIR_NAME), key=lambda x: str(x).lower()
+    )
+
+    if not site_packages:
+        raise ValueError(
+            f"Could not find '{VENV_INDICATOR_DIR_NAME}' directory in "
+            "virtual environment path."
+        )
+    for unique_dir in site_packages:
+        unique_dir = str(unique_dir)
+        if status is True:
+            sys.path.insert(1, unique_dir)
+            return
+        else:
+            if sys.path[1] == unique_dir:
+                sys.path.pop(1)
+                return
+            else:
+                try:
+                    sys.path.remove(unique_dir)
+                except ValueError as e:
+                    raise RuntimeError(
+                        f"Virtual environment directory "
+                        f"{unique_dir} couldn't be removed from sys.path!"
+                    ) from e
+                else:
+                    return

elapi/cli/doc.py

@@ -29,7 +29,8 @@ __PARAMETERS__doc__ = {
                         "'10' is the sub-endpoint ID of sub-endpoint 'uploads' of the API URL "
                         "_'https://demo.elabftw.net/api/v2/experiments/1/uploads/`10`/'_.",
     "query": "HTTP query to pass to API URL.\n"
-             "- The value (parameters) for --query should be in **JSON** format. "
+             "- The value (parameters) for --query can be a string in **JSON** format, or "
+             "a JSON or YAML **file path**. "
              f"E.g., `{APP_NAME} get experiments <experiment ID> --query '{{\"format\": \"csv\"}}'` "
              f"will make a `GET` request to "
              f"_'https://demo.elabftw.net/api/v2/experiments/\<experiment ID\>/?format=csv'_ "
@@ -42,14 +43,17 @@ __PARAMETERS__doc__ = {
     #         f"`{APP_NAME} post teams -d '{{\"name\": \"Alpha\"}}'`, 2. As regular options. E.g., "
     #         f"`{APP_NAME} post teams --name Alpha`.",
     "data": f"HTTP POST data. This works similar to how data is passed to `curl`. E.g., "
-            f"`{APP_NAME} post teams -d '{{\"name\": \"Alpha\"}}'`,",
-    "file_post": "Send a file with a request. The value for --file should be in **JSON** format. The value must follow "
+            f"`{APP_NAME} post teams -d '{{\"name\": \"Alpha\"}}'`. Instead of a JSON string, "
+            f"a JSON or YAML **file path** can also be passed to --data/-d.",
+    "file_post": "Send a file with a request. The value for --file can be a string in **JSON** format, or "
+                 "a JSON or YAML **file path**. The value must follow "
                  "one of the following structures: `'{\"file\": \"<file path>\"}'`, "
                  "`'{\"file\": \"<file path>\", \"comment\": \"<file comment>\"}'`, "
                  "`'{\"file\": [\"<file new name>\", \"<file path>\"]}'`, or "
                  "`'{\"file\": [\"<file new name>\", \"<file path>\"], \"comment\": \"<file comment>\"}'`.",
     "data_patch": f"Modified data to be sent as HTTP PATCH data. This works similar to how data is passed to `curl`. "
-                  f'E.g., `{APP_NAME} patch teams --id <team id> -d \'{{"name": "New team name"}}\'`,',
+                  f'E.g., `{APP_NAME} patch teams --id <team id> -d \'{{"name": "New team name"}}\'`. '
+                  f'Instead of a JSON string, a JSON or YAML **file path** can also be passed to --data/-d.',
     "get_loc": "When _--get-loc_ is passed, if the request is successful, instead of printing the success message, "
                f"{APP_NAME} returns the ID and the URL (separated by comma) of the newly created resource that can "
                f"be used to just modify or do automation with the resource later on. The ID and the URL can be "
@@ -89,7 +93,8 @@ __PARAMETERS__doc__ = {
     "timeout": f"Maximum number of seconds {APP_NAME} will wait for response before giving up. "
                f"Default timeout is **5** seconds.",
     "headers": f"{APP_NAME} decides the appropriate headers in most cases. --headers will let you overwrite "
-               f"the default headers sent. The value for --headers should be in **JSON** format. E.g., "
+               f"the default headers sent. The value for --headers can be a string in **JSON** format, "
+               f"or a JSON or YAML **file path**. E.g., "
                f"`{APP_NAME} get info --headers '{{\"Accept\": \"application/json\", \"User-Agent\": "
                f"\"My custom agent 1.0\"}}'`.",
     "no_keys": "Do not show the names of configuration keywords.",
@@ -99,11 +104,9 @@ __PARAMETERS__doc__ = {
     "init_export_dir": f"Preferred export directory. If '--export-dir' isn't passed, {EXPORT_DIR} will be "
                         "set as the export directory.",
     "cli_startup": f"⚡️Force override detected configuration from '{CONFIG_FILE_NAME}'. "
-                     "The value should be in **JSON** format. This option can only be passed "
-                     "**before** passing any other argument/option/command. E.g., "
-                     '`elapi --OC \'{"timeout": "10", "verify_ssl": "false"}\' get info -F yml`. '
-                   'You can use tools like [yq](https://mikefarah.gitbook.io/yq) and '
-                   '[jq](https://jqlang.github.io/jq/) to read values from YAML and JSON _files_ respectively, '
-                   'if you do not wish to hand-type JSON syntax. E.g., '
-                   '`elapi --OC "$(cat ~/params.yml | yq e -o json -I0)" experiments get -i <experiment ID> -F csv`.',
+                     "The value can be in **JSON** format as a string, or a JSON or YAML **file path**. "
+                     "This option can only be passed **before** passing any other "
+                     "argument/option/command. E.g., "
+                     '`elapi --OC \'{"timeout": "10", "verify_ssl": "false"}\' get info -F yml`, '
+                     'or `elapi --OC "~/.quick-config.yml" get info -F yml`.',
 }