Add small bit of type hinting

src/rez/plugin_managers.py

@@ -5,22 +5,26 @@
 """
 Manages loading of all types of Rez plugins.
 """
+import pkgutil
+import os.path
+import sys
+from types import ModuleType
+from typing import Dict, List, Optional, Type
+from zipimport import zipimporter
+
 from rez.config import config, expand_system_vars, _load_config_from_filepaths
 from rez.utils.formatting import columnise
 from rez.utils.schema import dict_to_schema
 from rez.utils.data_utils import LazySingleton, cached_property, deep_update
 from rez.utils.logging_ import print_debug, print_warning
+from rez.vendor.schema.schema import Schema
 from rez.exceptions import RezPluginError
-from zipimport import zipimporter
-import pkgutil
-import os.path
-import sys
 
 
 # modified from pkgutil standard library:
 # this function is called from the __init__.py files of each plugin type inside
 # the 'rezplugins' package.
-def extend_path(path, name):
+def extend_path(path: List[str], name: str):
     """Extend a package's path.
 
     Intended use is to place the following code in a package's __init__.py:
@@ -85,23 +89,23 @@ class RezPluginType(object):
     'type_name' must correspond with one of the source directories found under
     the 'plugins' directory.
     """
-    type_name = None
+    type_name: Optional[str] = None
 
     def __init__(self):
         if self.type_name is None:
             raise TypeError("Subclasses of RezPluginType must provide a "
                             "'type_name' attribute")
-        self.pretty_type_name = self.type_name.replace('_', ' ')
-        self.plugin_classes = {}
-        self.failed_plugins = {}
-        self.plugin_modules = {}
-        self.config_data = {}
+        self.pretty_type_name: str = self.type_name.replace('_', ' ')
+        self.plugin_classes: Dict[str, Type[object]] = {}
+        self.failed_plugins: Dict[str, str] = {}
+        self.plugin_modules: Dict[str, ModuleType] = {}
+        self.config_data: Dict[str, Dict] = {}
         self.load_plugins()
 
     def __repr__(self):
         return '%s(%s)' % (self.__class__.__name__, self.plugin_classes.keys())
 
-    def register_plugin(self, plugin_name, plugin_class, plugin_module):
+    def register_plugin(self, plugin_name: str, plugin_class: Type[object], plugin_module: ModuleType):
         # TODO: check plugin_class to ensure it is a sub-class of expected base-class?
         # TODO: perhaps have a Plugin base class. This introduces multiple
         # inheritance in Shell class though :/
@@ -222,7 +226,7 @@ def get_plugin_module(self, plugin_name):
                                  % (self.pretty_type_name, plugin_name))
 
     @cached_property
-    def config_schema(self):
+    def config_schema(self) -> Schema:
         """Returns the merged configuration data schema for this plugin
         type."""
         from rez.config import _plugin_config_dict
@@ -235,7 +239,7 @@ def config_schema(self):
                 deep_update(d, d_)
         return dict_to_schema(d, required=True, modifier=expand_system_vars)
 
-    def create_instance(self, plugin, **instance_kwargs):
+    def create_instance(self, plugin, **instance_kwargs) -> "RezPluginType":
         """Create and return an instance of the given plugin."""
         return self.get_plugin_class(plugin)(**instance_kwargs)
 
@@ -294,7 +298,7 @@ def register_plugin():
             'rezplugins' is always found first.
     """
     def __init__(self):
-        self._plugin_types = {}
+        self._plugin_types: Dict[str, LazySingleton] = {}
 
     @cached_property
     def rezplugins_module_paths(self):
@@ -329,7 +333,7 @@ def rezplugins_module_paths(self):
 
     # -- plugin types
 
-    def _get_plugin_type(self, plugin_type):
+    def _get_plugin_type(self, plugin_type: str) -> RezPluginType:
         try:
             return self._plugin_types[plugin_type]()
         except KeyError:
@@ -366,7 +370,7 @@ def get_plugin_module(self, plugin_type, plugin_name):
         plugin = self._get_plugin_type(plugin_type)
         return plugin.get_plugin_module(plugin_name)
 
-    def get_plugin_config_data(self, plugin_type):
+    def get_plugin_config_data(self, plugin_type: str) -> Dict[str, Dict]:
         """Return the merged configuration data for the plugin type."""
         plugin = self._get_plugin_type(plugin_type)
         return plugin.config_data