Extract text from CLI to enable internationalisation

eth2deposit/cli/existing_mnemonic.py

@@ -4,6 +4,7 @@
 )
 
 from eth2deposit.exceptions import ValidationError
+from eth2deposit.intl.utils import load_text
 from eth2deposit.key_handling.key_derivation.mnemonic import (
     verify_mnemonic,
 )
@@ -20,51 +21,40 @@ def validate_mnemonic(cts: click.Context, param: Any, mnemonic: str) -> str:
     if verify_mnemonic(mnemonic, WORD_LISTS_PATH):
         return mnemonic
     else:
-        raise ValidationError('That is not a valid mnemonic, please check for typos.')
+        raise ValidationError(load_text('en', ['err_invalid_mnemonic']))
 
 
 @click.command(
-    help='Generate (or recover) keys from an existing mnemonic',
+    help=load_text('en', ['arg_existing_mnemonic', 'help']),
 )
 @click.pass_context
 @click.option(
-    '--mnemonic',
+    load_text('en', ['arg_mnemonic', 'argument']),
     callback=validate_mnemonic,
-    help=('The mnemonic that you used to generate your keys. (It is recommended not to use this argument, and wait for '
-          'the CLI to ask you for your mnemonic as otherwise it will appear in your shell history.)'),
-    prompt='Please enter your mnemonic separated by spaces (" ")',
+    help=load_text('en', ['arg_mnemonic', 'help']),
+    prompt=load_text('en', ['arg_mnemonic', 'prompt']),
     required=True,
     type=str,
 )
 @click.password_option(
-    '--mnemonic-password',
+    load_text('en', ['arg_mnemonic_password', 'argument']),
     default='',
-    help=('This is almost certainly not the argument you are looking for: it is for mnemonic passwords, not keystore '
-          'passwords. Providing a password here when you didn\'t use one initially, can result in lost keys (and '
-          'therefore funds)! Also note that if you used this tool to generate your mnemonic intially, then you did not '
-          'use a mnemonic password. However, if you are certain you used a password to "increase" the security of your '
-          'mnemonic, this is where you enter it.'),
+    help=load_text('en', ['arg_mnemonic_password', 'help']),
     prompt=False,
 )
 @click.option(
-    '--validator_start_index',
+    load_text('en', ['arg_validator_start_index', 'argument']),
     confirmation_prompt=True,
     default=0,
-    help=('Enter the index (key number) you wish to start generating more keys from. '
-          'For example, if you\'ve generated 4 keys in the past, you\'d enter 4 here,'),
-    prompt=('Enter the index (key number) you wish to start generating more keys from. '
-            'For example, if you\'ve generated 4 keys in the past, you\'d enter 4 here,'),
+    help=load_text('en', ['arg_validator_start_index', 'help']),
+    prompt=load_text('en', ['arg_validator_start_index', 'prompt']),
     type=click.IntRange(0, 2**32 - 1),
 )
 @generate_keys_arguments_decorator
 def existing_mnemonic(ctx: click.Context, mnemonic: str, mnemonic_password: str, **kwargs: Any) -> None:
     if mnemonic_password != '':
         click.clear()
-        click.confirm(
-            ('Are you absolutely certain that you used a mnemonic password? '
-             '(This is different from a keystore password!) '
-             'Using one when you are not supposed to can result in loss of funds!'),
-            abort=True)
+        click.confirm(load_text('en', ['msg_mnemonic_password_confirm']), abort=True)
 
     ctx.obj = {'mnemonic': mnemonic, 'mnemonic_password': mnemonic_password}
     ctx.forward(generate_keys)

eth2deposit/cli/generate_keys.py

@@ -9,6 +9,9 @@
     CredentialList,
 )
 from eth2deposit.exceptions import ValidationError
+from eth2deposit.intl.utils import (
+    load_text,
+)
 from eth2deposit.utils.validation import (
     verify_deposit_data_json,
     validate_password_strength,
@@ -36,23 +39,23 @@ def validate_password(cts: click.Context, param: Any, password: str) -> str:
     try:
         validate_password_strength(password)
     except ValidationError as e:
-        click.echo(f'Error: {e} Please retype.')
+        click.echo(e)
     else:
         is_valid_password = True
 
     while not is_valid_password:
-        password = get_password(text='Type the password that secures your validator keystore(s)')
+        password = get_password(load_text('en', ['msg_password_prompt']))
         try:
             validate_password_strength(password)
         except ValidationError as e:
-            click.echo(f'Error: {e} Please retype.')
+            click.echo(e)
         else:
             # Confirm password
-            password_confirmation = get_password(text='Repeat for confirmation')
+            password_confirmation = get_password(load_text('en', ['msg_password_confirm']))
             if password == password_confirmation:
                 is_valid_password = True
             else:
-                click.echo('Error: the two entered values do not match. Please retype again.')
+                click.echo(load_text('en', ['err_password_mismatch']))
 
     return password
 
@@ -64,32 +67,30 @@ def generate_keys_arguments_decorator(function: Callable[..., Any]) -> Callable[
     '''
     decorators = [
         click.option(
-            '--num_validators',
-            prompt='Please choose how many validators you wish to run',
-            help='The number of validators keys you want to generate (you can always generate more later)',
+            load_text('en', ['num_validators', 'argument']),
+            help=load_text('en', ['num_validators', 'help']),
+            prompt=load_text('en', ['num_validators', 'prompt']),
             required=True,
             type=click.IntRange(0, 2**32 - 1),
         ),
         click.option(
-            '--folder',
+            load_text('en', ['folder', 'argument']),
             default=os.getcwd(),
-            help='The folder to place the generated keystores and deposit_data.json in',
+            help=load_text('en', ['folder', 'help']),
             type=click.Path(exists=True, file_okay=False, dir_okay=True),
         ),
         click.option(
-            '--chain',
+            load_text('en', ['chain', 'argument']),
             default=MAINNET,
-            help='The version of eth2 you are targeting. use "mainnet" if you are depositing ETH',
-            prompt='Please choose the (mainnet or testnet) network/chain name',
+            help=load_text('en', ['chain', 'help']),
+            prompt=load_text('en', ['chain', 'prompt']),
             type=click.Choice(ALL_CHAINS.keys(), case_sensitive=False),
         ),
         click.password_option(
-            '--keystore_password',
+            load_text('en', ['keystore_password', 'argument']),
             callback=validate_password,
-            help=('The password that will secure your keystores. You will need to re-enter this to decrypt them when '
-                  'you setup your eth2 validators. (It is reccomened not to use this argument, and wait for the CLI '
-                  'to ask you for your mnemonic as otherwise it will appear in your shell history.)'),
-            prompt='Type the password that secures your validator keystore(s)',
+            help=load_text('en', ['keystore_password', 'help']),
+            prompt=load_text('en', ['keystore_password', 'prompt']),
         ),
     ]
     for decorator in reversed(decorators):
@@ -110,7 +111,7 @@ def generate_keys(ctx: click.Context, validator_start_index: int,
         os.mkdir(folder)
     click.clear()
     click.echo(RHINO_0)
-    click.echo('Creating your keys.')
+    click.echo(load_text('en', ['msg_key_creation']))
     credentials = CredentialList.from_mnemonic(
         mnemonic=mnemonic,
         mnemonic_password=mnemonic_password,
@@ -122,8 +123,8 @@ def generate_keys(ctx: click.Context, validator_start_index: int,
     keystore_filefolders = credentials.export_keystores(password=keystore_password, folder=folder)
     deposits_file = credentials.export_deposit_data_json(folder=folder)
     if not credentials.verify_keystores(keystore_filefolders=keystore_filefolders, password=keystore_password):
-        raise ValidationError("Failed to verify the keystores.")
+        raise ValidationError(load_text('en', ['err_verify_keystores']))
     if not verify_deposit_data_json(deposits_file):
-        raise ValidationError("Failed to verify the deposit data JSON files.")
-    click.echo('\nSuccess!\nYour keys can be found at: %s' % folder)
-    click.pause('\n\nPress any key.')
+        raise ValidationError(load_text('en', ['err_verify_deposit']))
+    click.echo(load_text('en', ['msg_creation_success']) + folder)
+    click.pause(load_text('en', ['msg_pause']))

eth2deposit/intl/en/cli/existing_mnemonic.json

@@ -0,0 +1,27 @@
+{
+    "validate_mnemonic": {
+        "err_invalid_mnemonic": "That is not a valid mnemonic, please check for typos."
+    },
+    "<module>": {
+        "arg_existing_mnemonic": {
+            "help": "Generate (or recover) keys from an existing mnemonic"
+        },
+        "arg_mnemonic": {
+            "argument": "--mnemonic",
+            "help": "The mnemonic that you used to generate your keys. (It is recommended not to use this argument, and wait for the CLI to ask you for your mnemonic as otherwise it will appear in your shell history.)",
+            "prompt": "Please enter your mnemonic separated by spaces (\" \")"
+        },
+        "arg_mnemonic_password": {
+            "argument": "--mnemonic-password",
+            "help": "This is almost certainly not the argument you are looking for: it is for mnemonic passwords, not keystore passwords. Providing a password here when you didn't use one initially, can result in lost keys (and therefore funds)! Also note that if you used this tool to generate your mnemonic intially, then you did not use a mnemonic password. However, if you are certain you used a password to \"increase\" the security of your mnemonic, this is where you enter it."
+        },
+        "arg_validator_start_index": {
+            "argument": "--validator_start_index",
+            "help": "Enter the index (key number) you wish to start generating more keys from. For example, if you've generated 4 keys in the past, you'd enter 4 here.",
+            "prompt": "Enter the index (key number) you wish to start generating more keys from. For example, if you've generated 4 keys in the past, you'd enter 4 here."
+        }
+    },
+    "existing_mnemonic": {
+        "msg_mnemonic_password_confirm": "Are you absolutely certain that you used a mnemonic password? (This is different from a keystore password!) Using one when you are not supposed to can result in loss of funds!"
+    }
+}

eth2deposit/intl/en/cli/generate_keys.json

@@ -0,0 +1,35 @@
+{
+    "validate_password": {
+        "msg_password_prompt": "Type the password that secures your validator keystore(s)",
+        "msg_password_confirm": "Repeat for confirmation",
+        "err_password_mismatch": "Error: the two entered values do not match. Please type again."
+    },
+    "generate_keys_arguments_decorator": {
+        "num_validators": {
+            "argument": "--num_validators",
+            "help": "The number of validators keys you want to generate (you can always generate more later)",
+            "prompt": "Please choose how many validators you wish to run"
+        },
+        "folder": {
+            "argument": "--folder",
+            "help": "The number of validators keys you want to generate (you can always generate more later)"
+        },
+        "chain": {
+            "argument": "--chain",
+            "help": "The version of eth2 you are targeting. Use \"mainnet\" if you are depositing ETH",
+            "prompt": "Please choose the (mainnet or testnet) network/chain name"
+        },
+        "keystore_password": {
+            "argument": "--keystore_password",
+            "help": "The version of eth2 you are targeting. Use \"mainnet\" if you are depositing ETH",
+            "prompt": "The password that will secure your keystores. You will need to re-enter this to decrypt them when you setup your eth2 validators. (It is reccomened not to use this argument, and wait for the CLI to ask you for your mnemonic as otherwise it will appear in your shell history.)"
+        }
+    },
+    "generate_keys": {
+        "msg_key_creation": "Creating your keys.",
+        "msg_creation_success": "\nSuccess!\nYour keys can be found at: ",
+        "msg_pause": "\n\nPress any key.",
+        "err_verify_keystores": "Failed to verify the keystores.",
+        "err_verify_deposit": "Failed to verify the deposit data JSON files."
+    }
+}

eth2deposit/intl/utils.py

@@ -0,0 +1,42 @@
+import inspect
+from functools import reduce
+import json
+from typing import (
+    Any,
+    Dict,
+    List,
+)
+import os
+
+from eth2deposit.utils.constants import INTL_CONETENT_PATH
+
+
+def _get_from_dict(dataDict: Dict[str, Any], mapList: List[str]) -> str:
+    '''
+    Iterate nested dictionary
+    '''
+    return reduce(dict.get, mapList, dataDict)  # type: ignore
+
+
+def load_text(lang: str, params: List[str], file_path: str='', func: str='') -> str:
+    '''
+    Determine and return the appropriate internationalisation text for a given `lang` and `params`
+    '''
+    if file_path == '':
+        # Auto-detect file-path based on call stack
+        file_path = inspect.stack()[1].filename
+        file_path = file_path[:-3] + '.json'     # replace .py with .json
+
+    if func == '':
+        # Auto-detect function based on call stack
+        func = inspect.stack()[1].function
+
+    # Determine path to json text
+    file_path_list = os.path.normpath(file_path).split(os.path.sep)
+    rel_path_list = file_path_list[file_path_list.index('eth2deposit') + 1:]
+    json_path = os.path.join(INTL_CONETENT_PATH, lang, *rel_path_list)
+
+    # browse json until text is found
+    with open(json_path) as f:
+        text_dict = json.load(f)
+        return _get_from_dict(text_dict, [func] + params)

eth2deposit/utils/constants.py

@@ -13,6 +13,7 @@
 
 
 # File/folder constants
+INTL_CONETENT_PATH = os.path.join('eth2deposit', 'intl')
 WORD_LISTS_PATH = os.path.join('eth2deposit', 'key_handling', 'key_derivation', 'word_lists')
 DEFAULT_VALIDATOR_KEYS_FOLDER_NAME = 'validator_keys'
 

eth2deposit/utils/validation.py

@@ -68,4 +68,4 @@ def validate_deposit(deposit_data_dict: Dict[str, Any]) -> bool:
 
 def validate_password_strength(password: str) -> None:
     if len(password) < 8:
-        raise ValidationError(f"The password length should be at least 8. Got {len(password)}.")
+        raise ValidationError(f"The password length should be at least 8. Got {len(password)}. Please retype")