elapi 1.0.7.dev4__py3-none-any.whl → 1.0.7.dev6__py3-none-any.whl

elapi/VERSION

@@ -1 +1 @@
-1.0.7.dev4
+1.0.7.dev6

elapi/_names.py

@@ -38,6 +38,9 @@ KEY_HOST: str = "HOST"
 KEY_API_TOKEN: str = "API_TOKEN"
 KEY_EXPORT_DIR: str = "EXPORT_DIR"
 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"
 
 # Log data directory with root permission
 LOG_DIR_ROOT: Path = Path(f"/var/log/{APP_NAME}")

elapi/api/__init__.py

@@ -0,0 +1,15 @@
+# ruff: noqa: F401
+from .api import (
+    APIRequest,
+    ElabFTWURLError,
+    ElabFTWURL,
+    GETRequest,
+    AsyncGETRequest,
+    POSTRequest,
+    AsyncPOSTRequest,
+    PATCHRequest,
+    AsyncPATCHRequest,
+    DELETERequest,
+    AsyncDELETERequest,
+)
+from .endpoint import FixedEndpoint, FixedAsyncEndpoint

elapi/{api.py → api/api.py}

@@ -5,21 +5,33 @@ from typing import Union, Optional, Tuple
 from httpx import Response, Client, AsyncClient, Limits
 from httpx_auth import HeaderApiKey
 
-from .configuration import API_TOKEN, TOKEN_BEARER, HOST
+from ..configuration import (
+    TOKEN_BEARER,
+    get_active_host,
+    get_active_api_token,
+    get_active_enable_http2,
+    get_active_verify_ssl,
+    get_active_timeout,
+)
 
 
 class APIRequest(ABC):
-    __slots__ = "keep_session_open", "_client"
-    host: str = HOST
-    api_token: str = API_TOKEN
-    header_name: str = TOKEN_BEARER
+    __slots__ = "keep_session_open", "_client", "host", "api_token", "header_name"
 
     def __init__(self, keep_session_open: bool = False, **kwargs):
+        self.host: str = get_active_host()
+        self.api_token: str = get_active_api_token().token
+        self.header_name: str = TOKEN_BEARER
         self.keep_session_open = keep_session_open
+        enable_http2 = get_active_enable_http2()
+        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),
-            verify=True,
+            http2=enable_http2,
+            verify=verify_ssl,
+            timeout=timeout,
             **kwargs,
         )
 
@@ -94,13 +106,15 @@ class ElabFTWURL:
             "experiments_status",
             "items_status",
             "teamgroups",
+            "tags",
         ),
         "todolist": (),
         "unfinished_steps": (),
         "users": ("notifications",),
         "idps": (),
+        "import": (),
+        "exports": (),
     }
-    host = APIRequest.host
 
     def __init__(
         self,
@@ -116,6 +130,18 @@ class ElabFTWURL:
         self.sub_endpoint_id = sub_endpoint_id
         self.query = query
 
+    @property
+    def host(self) -> str:
+        return get_active_host()
+
+    @host.setter
+    def host(self, value):
+        raise AttributeError("Host value cannot be modified!")
+
+    @host.deleter
+    def host(self):
+        raise AttributeError("Host cannot be deleted!")
+
     @property
     def endpoint_name(self) -> str:
         return self._endpoint_name
@@ -138,10 +164,19 @@ class ElabFTWURL:
     @sub_endpoint_name.setter
     def sub_endpoint_name(self, value: str):
         if value is not None:
-            if value.lower() not in ElabFTWURL.VALID_ENDPOINTS[self.endpoint_name]:
+            if value.lower() not in (
+                valid_sub_endpoint_name := ElabFTWURL.VALID_ENDPOINTS[
+                    self.endpoint_name
+                ]
+            ):
+                if not valid_sub_endpoint_name:
+                    raise ElabFTWURLError(
+                        f"Endpoint '{self._endpoint_name}' does not have any sub-endpoint!"
+                    )
+
                 raise ElabFTWURLError(
                     f"A Sub-endpoint for endpoint '{self._endpoint_name}' must be "
-                    f"one of valid eLabFTW sub-endpoints: {', '.join(ElabFTWURL.VALID_ENDPOINTS[self.endpoint_name])}."
+                    f"one of valid eLabFTW sub-endpoints: {', '.join(valid_sub_endpoint_name)}."
                 )
             self._sub_endpoint_name = value
         else:
@@ -154,7 +189,7 @@ class ElabFTWURL:
     @endpoint_id.setter
     def endpoint_id(self, value):
         if value is not None:
-            if not re.match(r"^(\d+)$|^(me)$", value := str(value)):
+            if not re.match(r"^(\d+)$|^(me)$|^(current)$", value := str(value)):
                 # Although, eLabFTW primarily supports integer-only IDs, there are exceptions, like the alias
                 # ID "me" for receiving one's own user information.
                 raise ElabFTWURLError("Invalid endpoint ID (or entity ID).")
@@ -173,7 +208,7 @@ class ElabFTWURL:
                 "Sub-endpoint ID cannot be defined without first specifying its sub-endpoint name."
             )
         if value is not None:
-            if not re.match(r"^(\d+)$|^(me)$", value := str(value)):
+            if not re.match(r"^(\d+)$|^(me)$|^(current)$", value := str(value)):
                 raise ElabFTWURLError("Invalid sub-endpoint ID (or entity sub-ID).")
             self._sub_endpoint_id = value
         else:
@@ -191,7 +226,7 @@ class ElabFTWURL:
 
     def get(self) -> str:
         url = (
-            f"{ElabFTWURL.host}/{self.endpoint_name}/{self.endpoint_id}/"
+            f"{self.host}/{self.endpoint_name}/{self.endpoint_id}/"
             f"{self.sub_endpoint_name}/{self.sub_endpoint_id}"
         ).rstrip("/")
         if self.query:
@@ -205,12 +240,14 @@ class GETRequest(APIRequest):
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
 
-    def _make(self, *args) -> Response:
+    def _make(self, *args, headers: Optional[dict] = None, **kwargs) -> Response:
         endpoint_name, endpoint_id, sub_endpoint_name, sub_endpoint_id, query = args
         url = ElabFTWURL(
             endpoint_name, endpoint_id, sub_endpoint_name, sub_endpoint_id, query
         )
-        return super().client.get(url.get(), headers={"Accept": "application/json"})
+        return super().client.get(
+            url.get(), headers=headers or {"Accept": "application/json"}, **kwargs
+        )
 
     def close(self):
         super().close()
@@ -222,9 +259,15 @@ class GETRequest(APIRequest):
         sub_endpoint_name: Optional[str] = None,
         sub_endpoint_id: Union[int, str, None] = None,
         query: Optional[dict] = None,
+        **kwargs,
     ) -> Response:
         return super().__call__(
-            endpoint_name, endpoint_id, sub_endpoint_name, sub_endpoint_id, query
+            endpoint_name,
+            endpoint_id,
+            sub_endpoint_name,
+            sub_endpoint_id,
+            query,
+            **kwargs,
         )
 
 
@@ -234,7 +277,7 @@ class POSTRequest(APIRequest):
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
 
-    def _make(self, *args, **kwargs) -> Response:
+    def _make(self, *args, headers: Optional[dict] = None, **kwargs) -> Response:
         endpoint_name, endpoint_id, sub_endpoint_name, sub_endpoint_id, query = args
         url = ElabFTWURL(
             endpoint_name, endpoint_id, sub_endpoint_name, sub_endpoint_id, query
@@ -246,7 +289,8 @@ class POSTRequest(APIRequest):
         files = kwargs.pop("files", None)
         return super().client.post(
             url.get(),
-            headers={
+            headers=headers
+            or {
                 "Accept": "*/*",
                 # If json argument isn't empty, '"Content-Type": "application/json"' is automatically set.
                 # '"Content-Type": "multipart/form-data"', takes no effect, and
@@ -284,16 +328,19 @@ class POSTRequest(APIRequest):
 class AsyncPOSTRequest(APIRequest, is_async_client=True):
     __slots__ = ()
 
-    def __init__(self, **kwargs):
+    def __init__(
+        self,
+        limits=Limits(
+            max_connections=100, max_keepalive_connections=30, keepalive_expiry=60
+        ),
+        **kwargs,
+    ):
         super().__init__(
-            timeout=180,
-            limits=Limits(
-                max_connections=100, max_keepalive_connections=30, keepalive_expiry=60
-            ),
+            limits=limits,
             **kwargs,
         )
 
-    async def _make(self, *args, **kwargs) -> Response:
+    async def _make(self, *args, headers: Optional[dict] = None, **kwargs) -> Response:
         endpoint_name, endpoint_id, sub_endpoint_name, sub_endpoint_id, query = args
         url = ElabFTWURL(
             endpoint_name, endpoint_id, sub_endpoint_name, sub_endpoint_id, query
@@ -305,7 +352,7 @@ class AsyncPOSTRequest(APIRequest, is_async_client=True):
         files = kwargs.pop("files", None)
         return await super().client.post(
             url.get(),
-            headers={"Accept": "*/*"},
+            headers=headers or {"Accept": "*/*"},
             json=data,
             files=files,
             **kwargs,
@@ -340,23 +387,25 @@ class AsyncPOSTRequest(APIRequest, is_async_client=True):
 class AsyncGETRequest(APIRequest, is_async_client=True):
     __slots__ = ()
 
-    def __init__(self, **kwargs):
+    def __init__(
+        self,
+        limits=Limits(
+            max_connections=100, max_keepalive_connections=30, keepalive_expiry=60
+        ),
+        **kwargs,
+    ):
         super().__init__(
-            timeout=180,
-            limits=Limits(
-                max_connections=100, max_keepalive_connections=30, keepalive_expiry=60
-            ),
+            limits=limits,
             **kwargs,
         )
 
-    async def _make(self, *args) -> Response:
+    async def _make(self, *args, headers: Optional[dict] = None, **kwargs) -> Response:
         endpoint_name, endpoint_id, sub_endpoint_name, sub_endpoint_id, query = args
         url = ElabFTWURL(
             endpoint_name, endpoint_id, sub_endpoint_name, sub_endpoint_id, query
         )
         return await super().client.get(
-            url.get(),
-            headers={"Accept": "application/json"},
+            url.get(), headers=headers or {"Accept": "application/json"}, **kwargs
         )
 
     async def close(self):
@@ -370,9 +419,15 @@ class AsyncGETRequest(APIRequest, is_async_client=True):
         sub_endpoint_name: Optional[str] = None,
         sub_endpoint_id: Union[int, str, None] = None,
         query: Optional[dict] = None,
+        **kwargs,
     ) -> Response:
         response = await self._make(
-            endpoint_name, endpoint_id, sub_endpoint_name, sub_endpoint_id, query
+            endpoint_name,
+            endpoint_id,
+            sub_endpoint_name,
+            sub_endpoint_id,
+            query,
+            **kwargs,
         )
         if not self.keep_session_open:
             await self.close()
@@ -385,7 +440,7 @@ class PATCHRequest(APIRequest):
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
 
-    def _make(self, *args, **kwargs) -> Response:
+    def _make(self, *args, headers: Optional[dict] = None, **kwargs) -> Response:
         endpoint_name, endpoint_id, sub_endpoint_name, sub_endpoint_id, query = args
         url = ElabFTWURL(
             endpoint_name, endpoint_id, sub_endpoint_name, sub_endpoint_id, query
@@ -396,7 +451,8 @@ class PATCHRequest(APIRequest):
         }
         return super().client.patch(
             url.get(),
-            headers={
+            headers=headers
+            or {
                 "Accept": "application/json"
             },  # '"Content-Type": "application/json"' is passed automatically when json argument is passed.
             json=data,
@@ -428,16 +484,19 @@ class PATCHRequest(APIRequest):
 class AsyncPATCHRequest(APIRequest, is_async_client=True):
     __slots__ = ()
 
-    def __init__(self, **kwargs):
+    def __init__(
+        self,
+        limits=Limits(
+            max_connections=100, max_keepalive_connections=30, keepalive_expiry=60
+        ),
+        **kwargs,
+    ):
         super().__init__(
-            timeout=180,
-            limits=Limits(
-                max_connections=100, max_keepalive_connections=30, keepalive_expiry=60
-            ),
+            limits=limits,
             **kwargs,
         )
 
-    async def _make(self, *args, **kwargs) -> Response:
+    async def _make(self, *args, headers: Optional[dict] = None, **kwargs) -> Response:
         endpoint_name, endpoint_id, sub_endpoint_name, sub_endpoint_id, query = args
         url = ElabFTWURL(
             endpoint_name, endpoint_id, sub_endpoint_name, sub_endpoint_id, query
@@ -448,7 +507,7 @@ class AsyncPATCHRequest(APIRequest, is_async_client=True):
         }
         return await super().client.patch(
             url.get(),
-            headers={"Accept": "application/json"},
+            headers=headers or {"Accept": "application/json"},
             json=data,
             **kwargs,
         )
@@ -485,13 +544,15 @@ class DELETERequest(APIRequest):
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
 
-    def _make(self, *args) -> Response:
+    def _make(self, *args, headers: Optional[dict] = None, **kwargs) -> Response:
         endpoint_name, endpoint_id, sub_endpoint_name, sub_endpoint_id, query = args
         url = ElabFTWURL(
             endpoint_name, endpoint_id, sub_endpoint_name, sub_endpoint_id, query
         )
         return super().client.delete(
-            url.get(), headers={"Accept": "*/*", "Content-Type": "application/json"}
+            url.get(),
+            headers=headers or {"Accept": "*/*", "Content-Type": "application/json"},
+            **kwargs,
         )
 
     def close(self):
@@ -504,32 +565,42 @@ class DELETERequest(APIRequest):
         sub_endpoint_name: Optional[str] = None,
         sub_endpoint_id: Union[int, str, None] = None,
         query: Optional[dict] = None,
+        **kwargs,
     ) -> Response:
         return super().__call__(
-            endpoint_name, endpoint_id, sub_endpoint_name, sub_endpoint_id, query
+            endpoint_name,
+            endpoint_id,
+            sub_endpoint_name,
+            sub_endpoint_id,
+            query,
+            **kwargs,
         )
 
 
 class AsyncDELETERequest(APIRequest, is_async_client=True):
     __slots__ = ()
 
-    def __init__(self, **kwargs):
+    def __init__(
+        self,
+        limits=Limits(
+            max_connections=100, max_keepalive_connections=30, keepalive_expiry=60
+        ),
+        **kwargs,
+    ):
         super().__init__(
-            timeout=180,
-            limits=Limits(
-                max_connections=100, max_keepalive_connections=30, keepalive_expiry=60
-            ),
+            limits=limits,
             **kwargs,
         )
 
-    async def _make(self, *args) -> Response:
+    async def _make(self, *args, headers: Optional[dict] = None, **kwargs) -> Response:
         endpoint_name, endpoint_id, sub_endpoint_name, sub_endpoint_id, query = args
         url = ElabFTWURL(
             endpoint_name, endpoint_id, sub_endpoint_name, sub_endpoint_id, query
         )
         return await super().client.delete(
             url.get(),
-            headers={"Accept": "*/*", "Content-Type": "application/json"},
+            headers=headers or {"Accept": "*/*", "Content-Type": "application/json"},
+            **kwargs,
         )
 
     async def close(self):
@@ -543,9 +614,15 @@ class AsyncDELETERequest(APIRequest, is_async_client=True):
         sub_endpoint_name: Optional[str] = None,
         sub_endpoint_id: Union[int, str, None] = None,
         query: Optional[dict] = None,
+        **kwargs,
     ) -> Response:
         response = await self._make(
-            endpoint_name, endpoint_id, sub_endpoint_name, sub_endpoint_id, query
+            endpoint_name,
+            endpoint_id,
+            sub_endpoint_name,
+            sub_endpoint_id,
+            query,
+            **kwargs,
         )
         if not self.keep_session_open:
             await self.close()

elapi/{validators/permission.py → api/validators.py}

@@ -1,6 +1,105 @@
-from typing import Union, Optional
+from json import JSONDecodeError
+from typing import Union, Iterable, Optional
 
-from .base import Validator, RuntimeValidationError, CriticalValidationError
+import httpx
+
+from ..core_validators import Validator, RuntimeValidationError, CriticalValidationError
+from ..styles import stdin_console
+from ..styles.highlight import NoteText
+
+
+class HostIdentityValidator(Validator):
+    __slots__ = ()
+
+    def __init__(self, restrict_to: Union[str, Iterable[str], None] = None):
+        self.restrict_to = restrict_to
+
+    @property
+    def restrict_to(self) -> Iterable[str]:
+        return self._restrict_to
+
+    @restrict_to.setter
+    def restrict_to(self, value):
+        if value is None:
+            self._restrict_to = None
+        elif isinstance(value, str):
+            self._restrict_to = [value]
+        elif isinstance(value, Iterable):
+            self._restrict_to = value
+        else:
+            raise AttributeError(
+                "restrict_to must be a string of target host URL, or an iterable of strings where "
+                f"each string is a host URL that {HostIdentityValidator.__name__} validation will be restricted to."
+            )
+
+    @staticmethod
+    def check_endpoint():
+        from ..api import GETRequest
+
+        session = GETRequest()
+        return session(endpoint_name="apikeys", endpoint_id=None)
+
+    def validate(self):
+        from ..loggers import Logger
+        from ..configuration import get_active_host, get_active_api_token
+        from ..configuration import KEY_HOST
+
+        logger = Logger()
+        host = get_active_host()
+        api_token = get_active_api_token()
+        if self.restrict_to is not None:
+            if host not in self.restrict_to:
+                logger.error(
+                    f"Detected '{KEY_HOST.lower()}' is different from the restricted host. "
+                    f"'{KEY_HOST.lower()}' could not be validated!"
+                )
+                try:
+                    stdin_console.print(
+                        NoteText(
+                            f"Detected '{KEY_HOST.lower()}': '{host}'. "
+                            f"Host(s) restricted by {HostIdentityValidator.__name__}: '{', '.join(self.restrict_to)}'."
+                        )
+                    )
+                except TypeError as e:
+                    raise ValueError(
+                        f"An invalid value might have been given to restrict_to "
+                        f"attribute of {HostIdentityValidator.__name__}. Validation could not be completed!"
+                    ) from e
+                raise CriticalValidationError
+
+        API_TOKEN_MASKED = api_token
+        try:
+            response: httpx.Response = self.check_endpoint()
+            response.json()
+        except (httpx.HTTPError, JSONDecodeError) as error:
+            logger.critical(
+                f"There was a problem accessing host '{host}' with API token '{API_TOKEN_MASKED}'."
+            )
+            try:
+                # noinspection PyUnboundLocalVariable
+                logger.info(
+                    f"Returned response: '{response.status_code}: {response.text}'"
+                )
+            except UnboundLocalError:
+                logger.info(
+                    f"No request was made to the host URL! Exception details: '{error!r}'"
+                )
+                raise RuntimeValidationError
+            if response.is_server_error:
+                logger.critical(
+                    f"There was a problem with the host server: '{host}'. "
+                    f"Please contact an administrator."
+                )
+                raise RuntimeValidationError
+            stdin_console.print(
+                NoteText(
+                    "There is likely nothing wrong with the host server. "
+                    "Possible reasons for failure:\n"
+                    "• Invalid/expired/incorrect API token\n"
+                    "• Incorrect host URL\n",
+                )
+            )
+            raise RuntimeValidationError
 
 
 class PermissionValidator(Validator):
@@ -63,13 +162,12 @@ class PermissionValidator(Validator):
     def validate(self) -> None:
         from ..api import GETRequest
         from ..loggers import Logger
-        from .identity import COMMON_NETWORK_ERRORS, HostIdentityValidator
 
         logger = Logger()
         try:
             session = GETRequest(keep_session_open=True)
             caller_data: dict = session(endpoint_name="users", endpoint_id="me").json()
-        except COMMON_NETWORK_ERRORS:
+        except (httpx.HTTPError, JSONDecodeError):
             logger.critical(
                 "Something went wrong while trying to read user information! "
                 f"Try to validate the configuration first with '{HostIdentityValidator.__name__}' "
@@ -111,7 +209,6 @@ class APITokenRWValidator(Validator):
 
     def validate(self):
         from ..api import GETRequest
-        from .identity import COMMON_NETWORK_ERRORS, HostIdentityValidator
         from ..loggers import Logger
 
         logger = Logger()
@@ -121,7 +218,7 @@ class APITokenRWValidator(Validator):
                 api_token_data: Optional[dict] = _session(
                     endpoint_name="apikeys", endpoint_id="me"
                 ).json()[0]
-            except COMMON_NETWORK_ERRORS:
+            except (httpx.HTTPError, JSONDecodeError):
                 logger.critical(
                     "Something went wrong while trying to read API token information! "
                     f"Try to validate the configuration first with '{HostIdentityValidator.__name__}' "

elapi/cli/__init__.py

@@ -1 +0,0 @@
-from ..plugins.commons.cli_helpers import CLIExport, CLIFormat, OrderedCommands  # noqa: F401

elapi/cli/__main__.py

@@ -1,3 +1,4 @@
 from .elapi import app
+from .. import APP_NAME
 
-app(prog_name="elapi")
+app(prog_name=APP_NAME)

elapi/cli/_plugin_handler.py

@@ -38,7 +38,10 @@ class InternalPluginHandler:
             )  # Python will find module relative to __package__ path,
             # without this module.__package__ change Python will throw an ImportError.
             spec.loader.exec_module(module)
-            yield getattr(module, INTERNAL_PLUGIN_TYPER_APP_VAR_NAME)
+            try:
+                yield getattr(module, INTERNAL_PLUGIN_TYPER_APP_VAR_NAME)
+            except AttributeError:
+                yield
 
 
 internal_plugin_typer_apps = InternalPluginHandler().get_typer_apps()

elapi/cli/doc.py

@@ -1,6 +1,7 @@
 """
 This script includes docstring for elapi. The docstrings are mainly meant to be used with a CLI interface.
 """
+from .._names import CONFIG_FILE_NAME
 from ..configuration import APP_NAME, DEFAULT_EXPORT_DATA_FORMAT, EXPORT_DIR
 from ..styles import BaseFormat
 
@@ -82,10 +83,27 @@ __PARAMETERS__doc__ = {
               " to some external formatting program like `less`. "
               "If an unsupported format value is provided then the output format "
               f"falls back to `{DEFAULT_EXPORT_DATA_FORMAT.upper()}`.",
+    "verify": "SSL certificates are verified for HTTPS requests by default. Passing _'--verify False'_ will "
+              "disable the verification. This can be useful during local development. You can also pass a "
+              "path to SSL certificate (a.k.a CA bundle) file to --verify.",
+    "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"`{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.",
     "init_host": 'The host URL of your eLabFTW instance. It will look like \"https://demo.elabftw.net/api/v2\".',
     "init_api_token": 'API token (or API key) of your eLabFTW instance. You can generate it from eLabFTW "User Panel". '
                       'Make sure your API key has proper permission for your future tasks.',
     "init_export_dir": f"Preferred export directory. If '--export-dir' isn't passed, {EXPORT_DIR} will be "
-                        "set as the export directory."
+                        "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`.',
 }