Optionals

setup.py

@@ -9,7 +9,7 @@
 
 
 setup(
-    name='ecosystemS',
+    name='ecosystem',
     version=version_mod.__version__,
     packages=find_packages(os.path.join(os.path.dirname(__file__), 'source')),
     package_dir={

source/ecosystem/__main__.py

@@ -31,7 +31,7 @@ def main(args=sys.argv[1:]):
     runcmd = []
     if ('-r' in args or '--run' in args):
         index = args.index('-r') if '-r' in args else args.index('--run')
-        runcmd += [args.pop(x) for x in reversed(range(index, len(args)))]
+        runcmd += [args.pop(x) for x in reversed(list(range(index, len(args))))]
         runcmd = list(reversed(runcmd))[1:]
 
     extra = []
@@ -51,8 +51,7 @@ def main(args=sys.argv[1:]):
     run_grp = parser.add_argument_group('run')
     run_grp.add_argument('-r', '--run', nargs='?', default=[''])
     run_grp.add_argument('--run-detached', action='store_true')
-    run_grp.add_argument('--run-shell', type=str2bool,
-                         default=platform.system() == 'Windows')
+    run_grp.add_argument('--run-shell', type=str2bool, default=platform.system() == 'Windows')
     run_grp.add_argument('--normalize-paths', action='store_true')
     run_grp.add_argument('--from-previous', action='store_true')
 
@@ -67,7 +66,25 @@ def main(args=sys.argv[1:]):
     extra += extra_
     logger.setLevel(levels.get(args.verbosity, logging.INFO))
 
-    eco = Ecosystem(normalize_paths=args.normalize_paths)
+    if args.tools:
+        eco = Ecosystem(normalize_paths=args.normalize_paths, wanted_tools=args.tools)
+    elif args.preset:
+        eco = Ecosystem(normalize_paths=args.normalize_paths)
+        wanted_tools = []
+        if len(args.preset) == 1:
+            preset = eco.get_preset(args.preset[0])
+            environment = preset.get_environment()
+        else:
+            environment = presets.merge(*[eco.get_preset(x) for x in args.preset])
+            environment.remove_duplicates()
+        for tool in environment.tools:
+            wanted_tools.append(tool.name)
+            # logger.info(tool.name)
+        # logger.info(wanted_tools)
+        eco = Ecosystem(normalize_paths=args.normalize_paths,  wanted_tools=wanted_tools)
+
+    else:
+        eco = Ecosystem(normalize_paths=args.normalize_paths, wanted_tools=[])
 
     if args.list:
         sys.stdout.write('\n'.join(eco.list_tools()))
@@ -80,15 +97,17 @@ def main(args=sys.argv[1:]):
     if runcmd is not None:
         if not args.preset and not args.tools:
             parser.error(
-                'one of te arguments -t/--tools -p/--presets is required')
+                'one of the arguments -t/--tools -p/--presets is required.')
 
         if args.preset:
             if len(args.preset) == 1:
                 preset = eco.get_preset(args.preset[0])
                 environment = preset.get_environment()
+                # logger.info(environment.tools)
+                # for tool in environment.tools:
+                #     logger.info(tool.name)
             else:
-                environment = presets.merge(*[eco.get_preset(x)
-                                              for x in args.preset])
+                environment = presets.merge(*[eco.get_preset(x) for x in args.preset])
                 environment.remove_duplicates()
 
             if not runcmd:

source/ecosystem/_version.py

@@ -1,6 +1,6 @@
 VERSION_MAJOR = 0
 VERSION_MINOR = 8
-VERSION_PATCH = 0
+VERSION_PATCH = 5
 
 version_info = (VERSION_MAJOR, VERSION_MINOR, VERSION_PATCH)
 version = '%i.%i.%i' % version_info

source/ecosystem/eco.py

@@ -21,30 +21,36 @@
 
 
 class Ecosystem(object):
-    def __init__(
-            self, env_search_paths=None, plugin_searach_paths=None,
-            preset_search_paths=None, force_platform=None,
-            normalize_paths=False):
+    '''Define the whole ecosystem'''
+
+    def __init__(self,
+                 env_search_paths=None,
+                 plugin_search_paths=None,
+                 preset_search_paths=None,
+                 force_platform=None,
+                 normalize_paths=False,
+                 wanted_tools=[]):
         self.search_paths = env_search_paths or \
             os.getenv('ECO_ENV', '').split(os.pathsep)
 
         self.force_platform = force_platform or platform.system().lower()
 
         self._tools = {}
         self.filehandler = handlers.FileHandlerManager()
+        self._wanted_tools = wanted_tools
         self.discover()
-        self.pluginmanager = plugins.PluginManager(self, plugin_searach_paths)
+        self.pluginmanager = plugins.PluginManager(self, plugin_search_paths)
         self.presetmanager = presets.PresetManager(self, preset_search_paths)
         self._normalize_paths = normalize_paths
 
     def discover(self, append=False):
         if not append:
             self._tools = {}
-
+        # logger.debug('Search Paths are {}.'.format(self.search_paths))
         for path in self.search_paths:
 
             if not os.path.isdir(path):
-                logger.debug('Path %s is not a directory. Skipping.' % path)
+                logger.debug('Path {} is not a directory. Skipping.'.format(path))
                 continue
 
             for envfile in os.listdir(path):
@@ -61,18 +67,15 @@ def discover(self, append=False):
                 try:
                     tools = handler.read_env(envfile_path)
                 except Exception as e:
-                    logger.warn('Could not read "%s": %s' % (envfile_path, e))
+                    logger.warn('Could not read "{0}": {1}'.format(envfile_path, e))
                     logger.debug(traceback.format_exc())
                     continue
 
                 for _tool in tools:
                     try:
                         versions = _tool['version']
                     except KeyError:
-                        logger.warn(
-                            'Tool from "%s" does not have any version.' %
-                            envfile_path
-                        )
+                        logger.warn('Tool from "{}" has no version.'.format(envfile_path))
                         continue
 
                     if isinstance(versions, basestring):
@@ -88,31 +91,22 @@ def discover(self, append=False):
                                 requires=_tool.get('requires', []),
                                 environment=_tool['environment'],
                                 optional=_tool.get('optional', {}),
-                                force_platform=self.force_platform,
-                                source=envfile_path
+                                source=envfile_path,
+                                wanted_tools=self._wanted_tools,
+                                force_platform=self.force_platform
                             )
                             if not tool_obj.valid:
-                                message = (
-                                    'Skipping tool "%s": '
-                                    'not supported for platform "%s"'
-                                )
-                                logger.debug(message % (
-                                    tool_obj.name, self.force_platform))
+                                message = ('Skipping tool "{0}": not supported for platform "{1}"')
+                                logger.debug(message.format(tool_obj.name, self.force_platform))
                                 continue
 
                         except Exception as e:
-                            logger.warn(
-                                'Could not load env file "%s": %s.' % (
-                                    envfile_path, e)
-                            )
+                            logger.warn('Could not load env file "%s": %s.' % (envfile_path, e))
                             logger.debug(traceback.format_exc())
                             continue
 
                         if self._tools.get(tool_obj.name):
-                            logger.debug(
-                                'Overriding duplicate tool "%s"' %
-                                tool_obj.name
-                            )
+                            logger.debug('Overriding duplicate tool "{}"'.format(tool_obj.name))
 
                         self._tools[tool_obj.name] = tool_obj
 
@@ -147,7 +141,10 @@ def get_preset(self, name):
 
 
 class Environment(object):
+    '''Once initialized this will represent the environment defined by the wanted tools'''
+
     def __init__(self, ecosystem, *tools):
+
         self.tools = tools
         self.ecosystem = ecosystem
         self._normalize_paths = False
@@ -210,19 +207,19 @@ def remove_duplicates(self):
             if tool.tool in tooldict:
                 logger.debug(
                     ('Duplicate tool "{}" found environment. '
-                     'Using exiting tool "{}"'
+                     'Using existing tool "{}"'
                      ).format(tool.name, tooldict[tool.tool].name)
                 )
                 continue
 
             tooldict[tool.tool] = tool
 
-        self.tools = tooldict.values()
+        self.tools = list(tooldict.values())
 
     def _serializable_environ(self):
         environ = {}
 
-        for key, val in os.environ.items():
+        for key, val in list(os.environ.items()):
             environ[str(key)] = str(val)
         return environ
 
@@ -279,7 +276,7 @@ def resolve(self, store_previous=True):
             os.environ[str(curr_var.key)] = str(os.pathsep.join(prev))
 
         for i in range(3):
-            for env_name, env_value in os.environ.items():
+            for env_name, env_value in list(os.environ.items()):
                 os.environ[env_name] = os.path.expandvars(env_value)
 
         tools = ','.join([x.name for x in self.tools])

source/ecosystem/handlers.py

@@ -1,9 +1,15 @@
 import json
 import os
 import logging
-import imp
 import sys
 
+try:
+    # Python 2
+    from imp import load_source as import_module
+except:
+    # Python 3
+    from importlib.machinery import SourceFileLoader as import_module
+
 logger = logging.getLogger(__name__)
 
 
@@ -67,14 +73,14 @@ def read_preset(self, file_path):
 class PythonHandler(BaseFileHandler):
     extensions = ['.py']
 
-    def check_compatibility(self):
-        if not sys.version_info[0] == 2:
-            raise NotImplementedError('Python 3 not supported.')
+    def check_python_version(self):
+        if not sys.version_info[0] > 2:
+            logger.info('You are using Python {}'.format(sys.version_info[0]))
 
     def read_module(self, file_path):
-        self.check_compatibility()
+        self.check_python_version()
 
-        module = imp.load_source(
+        module = import_module(
             os.path.splitext(os.path.split(file_path)[-1])[0],
             file_path
         )
@@ -95,7 +101,7 @@ def read_preset(self, file_path):
         module = self.read_module(file_path)
 
         if not hasattr(module, 'get_presets'):
-            logger.warn('Env file "%s" does not have "get_presets" function')
+            logger.warn('Preset file "%s" does not have "get_presets" function')
             return []
 
         return module.get_presets()

source/ecosystem/plugins.py

@@ -1,11 +1,15 @@
 import os
-import imp
 import logging
-import sys
 import traceback
 
 logger = logging.getLogger(__name__)
 
+try:
+    # Python 2
+    from imp import load_source as import_module
+except:
+    # Python 3
+    from importlib.machinery import SourceFileLoader as import_module
 
 class PluginManager(object):
     def __init__(self, ecosystem, search_paths=None):
@@ -33,17 +37,14 @@ def discover(self):
                 if not ext == '.py':
                     continue
 
-                if sys.version_info[0] == 2:
-                    try:
-                        module = imp.load_source(name, plugin_path)
-                    except Exception as e:
-                        logger.warn(
-                            'Could not load plugin "%s": %s' % (plugin_path, e)
-                        )
-                        logger.debug(traceback.format_exc())
-                        continue
-                else:
-                    raise NotImplementedError('Python 3 not supported.')
+                try:
+                    module = import_module(name, plugin_path)
+                except Exception as e:
+                    logger.warn(
+                        'Could not load plugin "%s": %s' % (plugin_path, e)
+                    )
+                    logger.debug(traceback.format_exc())
+                    continue
 
                 if not hasattr(module, 'initialize'):
                     logger.warn(

source/ecosystem/presets.py

@@ -40,7 +40,7 @@ def discover(self):
                 try:
                     presets = handler.read_preset(preset_path)
                 except Exception as e:
-                    logger.warn('Could not read "%s": %s' % (preset_path, e))
+                    logger.warn('Could not read preset in "%s": %s' % (preset_path, e))
                     logger.debug(traceback.format_exc())
                     continue
 
@@ -71,7 +71,7 @@ def discover(self):
     def expand_presets(self):
         sorted_presets = []
 
-        for preset in self._presets.values():
+        for preset in list(self._presets.values()):
             index = 0
             dependencies = preset.subpresets()
             for i, _preset in reversed(list(enumerate(sorted_presets))):
@@ -150,12 +150,12 @@ def run(self, command=None, detached=True):
         if not isinstance(command, (set, list, tuple)):
             command = [command]
 
-        command = map(str, command)
+        command = list(map(str, command))
 
         with environment:
             envs = environment.environ
 
-        for key, val in envs.items():
+        for key, val in list(envs.items()):
             envs[str(key)] = str(val)
 
         return utils.call_process(command, detached=detached, env=envs)