Add type annotation and docstrings to workload automation.

.gitignore

@@ -32,3 +32,5 @@ libs/armeabi
 doc/source/developer_information/developer_guide/instrument_method_map.rst
 doc/source/run_config/
 .eggs
+*venv*/*
+.vscode/*

doc/build_instrument_method_map.py

@@ -22,15 +22,15 @@
 from wa.framework.signal import CallbackPriority
 from wa.utils.doc import format_simple_table
 
-OUTPUT_TEMPLATE_FILE =  os.path.join(os.path.dirname(__file__), 'source', 'instrument_method_map.template')
+OUTPUT_TEMPLATE_FILE = os.path.join(os.path.dirname(__file__), 'source', 'instrument_method_map.template')
 
 
 def generate_instrument_method_map(outfile):
     signal_table = format_simple_table([(k, v) for k, v in SIGNAL_MAP.items()],
                                        headers=['method name', 'signal'], align='<<')
     decorator_names = map(lambda x: x.replace('high', 'fast').replace('low', 'slow'), CallbackPriority.names)
     priority_table = format_simple_table(zip(decorator_names, CallbackPriority.names, CallbackPriority.values),
-            headers=['decorator', 'CallbackPriority name', 'CallbackPriority value'],  align='<>')
+                                         headers=['decorator', 'CallbackPriority name', 'CallbackPriority value'], align='<>')
     with open(OUTPUT_TEMPLATE_FILE) as fh:
         template = string.Template(fh.read())
     with open(outfile, 'w') as wfh:

wa/__init__.py

@@ -30,7 +30,7 @@
 from wa.framework.resource import (NO_ONE, JarFile, ApkFile, ReventFile, File,
                                    Executable)
 from wa.framework.target.descriptor import (TargetDescriptor, TargetDescription,
-                                            create_target_description, add_description_for_target)
+                                            create_target_description)
 from wa.framework.workload import (Workload, ApkWorkload, ApkUiautoWorkload,
                                    ApkReventWorkload, UIWorkload, UiautoWorkload,
                                    PackageHandler, ReventWorkload, TestPackageHandler)

wa/commands/list.py

@@ -19,15 +19,21 @@
 from wa.framework.target.descriptor import list_target_descriptions
 from wa.utils.doc import get_summary
 from wa.utils.formatter import DescriptionListFormatter
+from argparse import Namespace
+from typing import TYPE_CHECKING, cast, Optional, List, Dict, Type
+if TYPE_CHECKING:
+    from wa.framework.pluginloader import __LoaderWrapper
+    from wa.framework.execution import ExecutionContext, ConfigManager
+    from wa.framework.plugin import Plugin
 
 
 class ListCommand(Command):
 
-    name = 'list'
-    description = 'List available WA plugins with a short description of each.'
+    name: str = 'list'
+    description: str = 'List available WA plugins with a short description of each.'
 
-    def initialize(self, context):
-        kinds = get_kinds()
+    def initialize(self, context: Optional['ExecutionContext']) -> None:
+        kinds: List[str] = get_kinds()
         kinds.extend(['augmentations', 'all'])
         self.parser.add_argument('kind', metavar='KIND',
                                  help=('Specify the kind of plugin to list. Must be '
@@ -48,8 +54,8 @@ def initialize(self, context):
                                  ''')
 
     # pylint: disable=superfluous-parens
-    def execute(self, state, args):
-        filters = {}
+    def execute(self, state: 'ConfigManager', args: Namespace) -> None:
+        filters: Dict[str, str] = {}
         if args.name:
             filters['name'] = args.name
 
@@ -74,16 +80,22 @@ def execute(self, state, args):
             list_plugins(args, filters)
 
 
-def get_kinds():
-    kinds = pluginloader.kinds
+def get_kinds() -> List[str]:
+    """
+    get a list of kinds of commands
+    """
+    kinds = cast('__LoaderWrapper', pluginloader).kinds
     if 'target_descriptor' in kinds:
         kinds.remove('target_descriptor')
         kinds.append('target')
     return ['{}s'.format(name) for name in kinds]
 
 
 # pylint: disable=superfluous-parens
-def list_targets():
+def list_targets() -> None:
+    """
+    print out target descriptions
+    """
     targets = list_target_descriptions()
     targets = sorted(targets, key=lambda x: x.name)
 
@@ -94,8 +106,11 @@ def list_targets():
     print('')
 
 
-def list_plugins(args, filters):
-    results = pluginloader.list_plugins(args.kind[:-1])
+def list_plugins(args, filters: Dict[str, str]) -> None:
+    """
+    print list of plugins
+    """
+    results = cast('__LoaderWrapper', pluginloader).list_plugins(args.kind[:-1])
     if filters or args.platform:
         filtered_results = []
         for result in results:
@@ -113,14 +128,14 @@ def list_plugins(args, filters):
 
     if filtered_results:
         output = DescriptionListFormatter()
-        for result in sorted(filtered_results, key=lambda x: x.name):
-            output.add_item(get_summary(result), result.name)
+        for result in sorted(filtered_results, key=lambda x: x.name or ''):
+            output.add_item(get_summary(result), result.name or '')
         print(output.format_data())
 
     print('')
 
 
-def check_platform(plugin, platform):
+def check_platform(plugin: Type['Plugin'], platform: str) -> bool:
     supported_platforms = getattr(plugin, 'supported_platforms', [])
     if supported_platforms:
         return platform in supported_platforms

wa/commands/process.py

@@ -19,28 +19,36 @@
 from wa import discover_wa_outputs
 from wa.framework.configuration.core import Status
 from wa.framework.exception import CommandError
-from wa.framework.output import RunOutput
+from wa.framework.output import RunOutput, JobOutput
 from wa.framework.output_processor import ProcessorManager
 from wa.utils import log
+from argparse import Namespace
+from typing import Optional, TYPE_CHECKING, List, cast
+from types import ModuleType
+if TYPE_CHECKING:
+    from wa.framework.target.info import TargetInfo
+    from wa.framework.execution import ExecutionContext, ConfigManager
 
 
 class ProcessContext(object):
-
-    def __init__(self):
-        self.run_output = None
-        self.target_info = None
-        self.job_output = None
+    """
+    process context
+    """
+    def __init__(self) -> None:
+        self.run_output: Optional[RunOutput] = None
+        self.target_info: Optional['TargetInfo'] = None
+        self.job_output: Optional[JobOutput] = None
 
     def add_augmentation(self, aug):
         pass
 
 
 class ProcessCommand(Command):
 
-    name = 'process'
-    description = 'Process the output from previously run workloads.'
+    name: str = 'process'
+    description: str = 'Process the output from previously run workloads.'
 
-    def initialize(self, context):
+    def initialize(self, context: Optional['ExecutionContext']) -> None:
         self.parser.add_argument('directory', metavar='DIR',
                                  help="""
                                  Specify a directory containing the data
@@ -69,14 +77,14 @@ def initialize(self, context):
                                  instead of just processing the root.
                                  """)
 
-    def execute(self, config, args):  # pylint: disable=arguments-differ,too-many-branches,too-many-statements
-        process_directory = os.path.expandvars(args.directory)
+    def execute(self, config: 'ConfigManager', args: Namespace):  # pylint: disable=arguments-differ,too-many-branches,too-many-statements
+        process_directory: str = os.path.expandvars(args.directory)
         self.logger.debug('Using process directory: {}'.format(process_directory))
         if not os.path.exists(process_directory):
-            msg = 'Path `{}` does not exist, please specify a valid path.'
+            msg: str = 'Path `{}` does not exist, please specify a valid path.'
             raise CommandError(msg.format(process_directory))
         if not args.recursive:
-            output_list = [RunOutput(process_directory)]
+            output_list: List[RunOutput] = [RunOutput(process_directory)]
         else:
             output_list = list(discover_wa_outputs(process_directory))
 
@@ -96,14 +104,14 @@ def execute(self, config, args):  # pylint: disable=arguments-differ,too-many-br
                 self.logger.info('Install output processors for run in path `{}`'
                                  .format(run_output.basepath))
 
-            logfile = os.path.join(run_output.basepath, 'process.log')
+            logfile: str = os.path.join(run_output.basepath, 'process.log')
             i = 0
             while os.path.exists(logfile):
                 i += 1
                 logfile = os.path.join(run_output.basepath, 'process-{}.log'.format(i))
             log.add_file(logfile)
 
-            pm = ProcessorManager(loader=config.plugin_cache)
+            pm = ProcessorManager(loader=cast(ModuleType, config.plugin_cache))
             for proc in config.get_processors():
                 pm.install(proc, pc)
             if args.additional_processors:
@@ -128,11 +136,12 @@ def execute(self, config, args):  # pylint: disable=arguments-differ,too-many-br
                 pc.job_output = job_output
                 pm.enable_all()
                 if not args.force:
-                    for augmentation in job_output.spec.augmentations:
-                        try:
-                            pm.disable(augmentation)
-                        except ValueError:
-                            pass
+                    if job_output.spec:
+                        for augmentation in job_output.spec.augmentations:
+                            try:
+                                pm.disable(augmentation)
+                            except ValueError:
+                                pass
 
                 msg = 'Processing job {} {} iteration {}'
                 self.logger.info(msg.format(job_output.id, job_output.label,