qmenta-core 5.2.0.dev728__tar.gz → 6.0.0.dev730__tar.gz

{qmenta_core-5.2.0.dev728 → qmenta_core-6.0.0.dev730}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: qmenta-core
-Version: 5.2.0.dev728
+Version: 6.0.0.dev730
 Summary: QMENTA core library to communicate with the QMENTA platform.
 License: Proprietary
 Author: QMENTA

{qmenta_core-5.2.0.dev728 → qmenta_core-6.0.0.dev730}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "qmenta-core"
-version = "5.2.0.dev728"
+version = "6.0.0.dev730"
 description = "QMENTA core library to communicate with the QMENTA platform."
 license = "Proprietary"
 authors = ["QMENTA <dev@qmenta.com>"]

{qmenta_core-5.2.0.dev728 → qmenta_core-6.0.0.dev730}/src/qmenta/core/auth.py

@@ -2,6 +2,7 @@ import argparse
 from enum import Enum, unique
 import os
 import requests
+import sys
 from getpass import getpass
 from pathlib import Path
 from typing import Optional, Dict
@@ -28,7 +29,9 @@ class InvalidLoginError(ActionFailedError):
 
 class Needs2FAError(ActionFailedError):
     """
-    When a 2FA code must to be provided to log in.
+    When the account has two-factor authentication enabled.
+    Username/password login with a 2FA code is no longer supported;
+    generate an API key instead and log in with it.
     """
     pass
 
@@ -114,25 +117,18 @@ class Auth:
     def login(cls,
               username: Optional[str] = None,
               password: Optional[str] = None,
-              code_2fa: Optional[str] = None,
               *,
               api_key: Optional[str] = None,
-              ask_for_2fa_input: bool = False,
               base_url: str = PlatformURL.platform.value) -> 'Auth':
         """
         Authenticate to the platform using username and password,
         or an API key.
 
-        ``api_key``, ``ask_for_2fa_input``, and ``base_url`` must be passed
-        as keyword arguments.
+        ``api_key`` and ``base_url`` must be passed as keyword arguments.
 
         Valid parameter combinations:
 
         - ``username``, ``password``: standard login.
-        - ``username``, ``password``, ``code_2fa``: login with a
-          pre-supplied 2FA code.
-        - ``username``, ``password``, ``ask_for_2fa_input=True``: login
-          and prompt for the 2FA code interactively when required.
         - ``api_key``: login using an API key.
 
         ``base_url`` can be combined with any of the above to target a
@@ -140,6 +136,11 @@ class Auth:
         When ``username`` + ``password`` and ``api_key`` are all provided,
         ``username`` + ``password`` takes precedence.
 
+        Accounts with two-factor authentication (2FA) enabled can no
+        longer log in with username and password: generate an API key
+        in the platform (My profile -> Credentials) and log in with
+        ``api_key`` instead.
+
         Parameters
         ----------
         username : str
@@ -148,20 +149,10 @@ class Auth:
             Example: 'example@qmenta.com'
         password : str
             The QMENTA platform password of the user.
-        code_2fa : str
-            The 2FA code that was sent to your phone (optional).
         api_key : str
             A QMENTA API key. See the platform manual to learn how to
             generate one. When provided together with ``username`` and
             ``password``, the username/password credentials take precedence.
-        ask_for_2fa_input: bool
-            When set to True, the user is asked input the 2FA code
-            in the command-line interface when it is needed. If the user does
-            not have 2FA enabled, no input is requested.
-            This is useful for scripts.
-            When set to False, a Needs2FAError exception is raised when
-            a 2FA code is needed. This is useful for GUIs.
-            Default value: False
         base_url : str
             The URL of the platform to connect to.
             Default value: 'https://platform.qmenta.com'
@@ -181,20 +172,15 @@ class Auth:
         InvalidLoginError
             If the login was invalid. This can happen when the
             username/password combination is incorrect, when the api_key is
-            invalid, when the account is not active, or when 2FA is required
-            to be set up. Also raised when neither credentials nor api_key
-            are provided.
+            invalid, when the account is not active. Also raised when
+            neither credentials nor api_key are provided.
         Needs2FAError
-            When a login attempt was done without a valid 2FA code.
-            The 2FA code has been sent to your phone, and must be provided
-            in the next call to the login function.
+            When the account has two-factor authentication enabled.
+            Generate an API key and log in with it instead.
         """
         url: str = urljoin(base_url, '/login')
         if username and password:
-            request_data = {
-                    'username': username, 'password': password,
-                    'code_2fa': code_2fa
-                }
+            request_data = {'username': username, 'password': password}
             headers = {}
         elif api_key:
             headers = {
@@ -231,17 +217,15 @@ class Auth:
             if data["success"] != 1:
                 # Login was not successful
                 if data.get("account_state", "") == '2fa_need':
-                    if ask_for_2fa_input:
-                        input_2fa = input("Please enter your 2FA code: ")
-                        return Auth.login(
-                            username, password, code_2fa=input_2fa,
-                            ask_for_2fa_input=True, base_url=base_url
-                        )
-                    else:
-                        raise Needs2FAError(
-                            'Provide the 2FA code sent to your phone, '
-                            'or set the ask_for_2fa_input parameter'
-                        )
+                    raise Needs2FAError(
+                        'This account has two-factor authentication '
+                        'enabled, which is no longer supported for '
+                        'username/password login. Generate an API key '
+                        'in the platform (My profile -> Credentials) '
+                        'and log in using an API key instead: pass it '
+                        'as the api_key parameter, or to the '
+                        'qmenta-auth --api-key command-line option.'
+                    )
                 else:
                     raise InvalidLoginError(data['error'])
 
@@ -344,36 +328,78 @@ def validate_url(url: str) -> None:
 
 
 def main() -> None:
+    """
+    Entry point of the ``qmenta-auth`` command-line tool.
+    """
     parser = argparse.ArgumentParser(
         description=(
             'Log in on QMENTA platform and store the authentication '
             'token in a .env file. Username and password may be '
             'provided as parameters, or will be asked as user input. '
+            'Alternatively, provide an API key, which is required for '
+            'accounts with two-factor authentication enabled.'
         )
     )
     parser.add_argument('--username', help='Username to login',)
     parser.add_argument('--password', help='Password')
+    api_key_group = parser.add_mutually_exclusive_group()
+    api_key_group.add_argument(
+        '--api-key',
+        help=(
+            'API key to login. See the platform manual to learn how '
+            'to generate one. Required if the account has two-factor '
+            'authentication enabled.'
+        )
+    )
+    api_key_group.add_argument(
+        '--ask-api-key', action='store_true',
+        help=(
+            'Ask for the API key as user input instead of passing it on '
+            'the command line, so that the key is not stored in the '
+            'shell history and is not visible in the process list. The '
+            'QMENTA_API_KEY environment variable is used when neither '
+            'option nor any username or password is given.'
+        )
+    )
     parser.add_argument(
         'url', help='Platform URL, for example: https://platform.qmenta.com')
     args = parser.parse_args()
 
+    if (args.api_key or args.ask_api_key) and (
+            args.username or args.password):
+        print(
+            'Provide either --username/--password or '
+            '--api-key/--ask-api-key, not both.',
+            file=sys.stderr
+        )
+        sys.exit(1)
+
+    api_key: Optional[str] = args.api_key
+    if api_key is None and not (
+            args.ask_api_key or args.username or args.password):
+        api_key = os.environ.get('QMENTA_API_KEY') or None
+
     try:
         validate_url(args.url)
     except ValueError as err:
-        print(err)
-        return
-
-    username = args.username or input("Username: ")
-    password = args.password or getpass()
+        print(err, file=sys.stderr)
+        sys.exit(1)
 
     try:
-        auth = Auth.login(
-            username=username, password=password,
-            ask_for_2fa_input=True, base_url=args.url
-        )
+        if args.ask_api_key:
+            api_key = getpass('API key: ')
+
+        if api_key is not None:
+            auth = Auth.login(api_key=api_key, base_url=args.url)
+        else:
+            username = args.username or input("Username: ")
+            password = args.password or getpass()
+            auth = Auth.login(
+                username=username, password=password, base_url=args.url
+            )
     except PlatformError as err:
-        print(err)
-        return
+        print(err, file=sys.stderr)
+        sys.exit(1)
 
     write_dot_env_file(token=auth.token, url=auth.base_url)