def find_drivers():
distros = pkg_resources.AvailableDistributions()
drivers = []
for key in distros:
resources = distros[key]
resource = resources[0]
egg = resource.egg_name()
folder = egg.split('-', 1)[0].lower()
path = os.path.join(resource.location, folder)
fname = os.path.join(path, '__init__.py')
if os.path.exists(fname):
with open(fname, 'r', encoding='utf-8') as f:
for line in f:
if '__site_url__' in line:
site_url = line.split('=')[-1].strip()[1:-1]
package = '{}=={}'.format(key, resource.version)
drivers.append((site_url, package, path))
break
return drivers
def scan(self, groups=None, group_re=None):
"""
walks through all distributions available and registers entry points or only those in `groups`
"""
import pkg_resources as pr
pr_env = pr.AvailableDistributions()
pr_env.scan()
if groups:
for group in groups:
self._backend.rm_group(group)
else:
self._backend.clear()
for dists in pr_env._distmap.values(): # pylint: disable=protected-access
dist = dists[0]
emap = dist.get_entry_map()
if groups:
dmap = {k: v for k, v in six.iteritems(emap) if k in groups}
elif group_re:
dmap = {
k: v
for k, v in six.iteritems(emap) if group_re.match(k)
}
else:
dmap = None
dname = dist.project_name
self._backend.write_dist(dname, entry_point_map=dmap)
def scan_all_group_names(self):
"""Use `pkg_resources` to get a set of all available (not only cached) groups."""
import pkg_resources as pr
pr_env = pr.AvailableDistributions()
pr_env.scan()
all_groups = set()
for dist_name in pr_env:
_, dmap = self._backend.scan_dist(dist_name)
all_groups.update(dmap.keys())
return all_groups
def _get_package_version(package_name):
import pkg_resources
try:
return pkg_resources.get_distribution(package_name).version
except Exception:
# Azure CLI exception loads azureml-* package in a special way which makes get_distribution not working
try:
all_packages = pkg_resources.AvailableDistributions() # scan sys.path
for name in all_packages:
if name == package_name:
return all_packages[name][0].version
except Exception:
# In case this approach is not working neither
return None
def scan(self, groups=None, group_re=None, nocommit=False, nodelete=False):
"""Walk through all distributions available and registers entry points or only those in `groups`."""
import pkg_resources as pr
pr_env = pr.AvailableDistributions()
pr_env.scan()
if not groups and group_re:
groups = []
if group_re:
if isinstance(group_re, six.string_types):
group_re = re.compile(group_re)
all_groups = self.scan_all_group_names()
groups.extend({group for group in all_groups if group_re.match(group)})
if not nocommit and not nodelete:
if groups:
for group in groups:
self._backend.rm_group(group)
else:
self._backend.clear()
full_map = {}
if nodelete:
full_map = self._backend.epmap.copy()
# ~ for dists in pr_env._distmap.values(): # pylint: disable=protected-access
for dist in pr_env:
dname, emap = self._backend.scan_dist(dist)
dmap = full_map.get(dname, {})
if groups:
new_dmap = {k: v for k, v in six.iteritems(emap) if k in groups}
dmap.update(new_dmap)
else:
dmap.update(emap)
# extract entry points that are reserved for other purposes unless excepted
dmap = clean_map(dmap, exceptions=groups)
if not nocommit:
self._backend.write_dist_map(dname, entry_point_map=dmap)
full_map[dname] = [dmap]
return full_map
def __init__(self, *args, **kwargs):
"""Creates a new instance of the
:class:`~rejected.consumer.SmartConsumer` class. To perform
initialization tasks, extend
:meth:`~rejected.consumer.SmartConsumer.initialize` or ensure you
:meth:`super` this method first.
"""
super(SmartConsumer, self).__init__(*args, **kwargs)
installed = pkg_resources.AvailableDistributions()
for key, pkg in {
'application/msgpack': 'u-msgpack-python',
'text/html': ('beautifulsoup4', 'lxml'),
'text/xml': ('beautifulsoup4', 'lxml')
}.items():
if isinstance(pkg, tuple):
self._SERIALIZATION_MAP[key]['enabled'] = \
all([p in installed for p in pkg])
else:
self._SERIALIZATION_MAP[key]['enabled'] = pkg in installed
self.logger.debug(
'%s is %s in serialization map', key, 'enabled'
if self._SERIALIZATION_MAP[key]['enabled'] else 'disabled')
def load_components(env):
loaded_components = []
# Load components from the environment plugins directory
plugins_dir = os.path.join(env.path, 'plugins')
if pkg_resources is not None: # But only if setuptools is installed!
distributions = pkg_resources.AvailableDistributions()
distributions.scan([plugins_dir])
for name in distributions:
egg = distributions[name][0]
if egg.metadata.has_metadata(TRAC_META):
env.log.debug('Loading component egg %s from %s', egg.name,
egg.path)
egg.install_on() # Put the egg on sys.path
for module in egg.metadata.get_metadata_lines(TRAC_META):
if module not in loaded_components:
try:
__import__(module)
loaded_components.append(module)
except ImportError, e:
env.log.error('Component module %s not found',
module,
exc_info=True)
for line in distribution.get_metadata_lines("RECORD"):
path, hash, size = line.split(",")
if path.endswith(".pth"):
with open(path) as pth:
return pth.readline().strip()
# fall back to the importable location (wheel install)
return distribution.location
else:
raise TypeError(
f"Unsupported distribution type {type(distribution)} {distribution}"
)
ampel_folders = {
_get_module_path(pkg_resources.get_distribution(dist_name)) # type: ignore
for dist_name in pkg_resources.AvailableDistributions() # type: ignore
if dist_name.startswith("pyampel") or dist_name.startswith("ampel-")
}
def load_ipython_extension(ipython):
pass
def clsimport(modname, local_ns=None):
clsname = modname.split(".")[-1]
if clsname in globals():
return
def install(package, dst_dir, params, run=None, profile=None):
"""Installs the services.
"""
_LOGGER.info('install: %s - %s, profile: %s', package, dst_dir, profile)
packages = [package]
module = plugin_manager.load('treadmill.bootstrap', package)
extension_module = None
if profile:
_LOGGER.info('Installing profile: %s', profile)
extension_name = '{}.{}'.format(package, profile)
packages.append(extension_name)
try:
extension_module = plugin_manager.load('treadmill.bootstrap',
extension_name)
except KeyError:
_LOGGER.info('Extension not defined: %s, profile: %s',
package, profile)
subproc.load_packages(packages, lazy=False)
# Store resolved aliases
aliases_path = os.path.join(dst_dir, '.aliases.json')
aliases = subproc.get_aliases()
with io.open(aliases_path, 'w') as f_aliases:
f_aliases.write(json.dumps(aliases))
defaults = {}
defaults.update(getattr(module, 'DEFAULTS', {}))
if extension_module:
defaults.update(getattr(extension_module, 'DEFAULTS', {}))
# TODO: this is ugly, error prone and should go away.
# aliases should be in default scope, everything else in _args.
defaults['_alias'] = aliases
defaults.update(aliases)
defaults.update(params)
defaults['aliases_path'] = aliases_path
os.environ['TREADMILL_ALIASES_PATH'] = defaults['aliases_path']
interpolated = bootstrap.interpolate(defaults, defaults)
fs.mkdir_safe(dst_dir)
with io.open(os.path.join(dst_dir, '.install'), 'w') as rec:
_install(module, PLATFORM, dst_dir, interpolated, rec=rec)
if extension_module:
_install(
extension_module,
'.'.join([profile, PLATFORM]), dst_dir, interpolated,
rec=rec
)
# Extract logging configuration.
logconf_dir = os.path.join(dst_dir, 'logging')
fs.mkdir_safe(logconf_dir)
tm_logging.write_configs(logconf_dir)
# Write entry-point cache
distributions = pkg_resources.AvailableDistributions()
plugin_manager.dump_cache(
os.path.join(dst_dir, 'plugins.json'), distributions
)
if run:
_run(run)
def main(self):
try:
dist = pkg_resources.get_distribution('steelscript')
except pkg_resources.DistributionNotFound:
print "Package not found: 'steelscript'"
print "Check the installation"
sys.exit(1)
e = pkg_resources.AvailableDistributions()
steelscript_pkgs = [x for x in e if x.startswith('steel')]
egg_info_pkgs = []
egg_link_pkgs = []
corrupted_pkgs = []
for p in steelscript_pkgs:
pkg = pkg_resources.get_distribution(p)
if pkg.location.endswith('site-packages'):
egg_info_pkgs.append(p)
else:
egg_link_pkgs.append(p)
if egg_info_pkgs and egg_link_pkgs:
corrupted_pkgs = egg_link_pkgs
print ""
print "Installed SteelScript Packages"
print "Core packages:"
core_pkgs = [
x for x in e if x.startswith('steel') and 'appfwk' not in x
]
core_pkgs.sort()
for p in core_pkgs:
pkg = pkg_resources.get_distribution(p)
if p in corrupted_pkgs:
print ' %-40s corrupted' % (pkg.project_name)
continue
print ' %-40s %s' % (pkg.project_name, pkg.version)
print ""
print "Application Framework packages:"
appfwk_pkgs = [x for x in e if x.startswith('steel') and 'appfwk' in x]
if appfwk_pkgs:
appfwk_pkgs.sort()
for p in appfwk_pkgs:
pkg = pkg_resources.get_distribution(p)
if p in corrupted_pkgs:
print ' %-40s corrupted' % (pkg.project_name)
continue
print ' %-40s %s' % (pkg.project_name, pkg.version)
else:
print " None"
print ""
print "REST tools and libraries:"
installed_rest = set(['reschema', 'sleepwalker']).intersection(set(e))
rest_pkgs = [pkg_resources.get_distribution(p) for p in installed_rest]
if rest_pkgs:
for pkg in rest_pkgs:
print ' %-40s %s' % (pkg.project_name, pkg.version)
else:
print " None"
print ""
print "Paths to source:"
paths = [os.path.dirname(p) for p in steelscript.__path__]
for pkg in rest_pkgs:
loc = pkg.location
if loc not in paths:
paths.append(loc)
paths.sort()
for p in paths:
print " %s" % p
if corrupted_pkgs:
print ""
print "WARNING: Corrupted installation detected"
print "Instructions to fix corrupted packages:"
print "1. pip uninstall <corrupted_package>"
print "2. pip install <corrupted_package>"
print " or do the following:"
print " cd <source_directory_of_corrupted_package>"
print " pip install ."
if self.options.verbose:
print ""
print "Python information:"
print ' Version :', platform.python_version()
print ' Version tuple:', platform.python_version_tuple()
print ' Compiler :', platform.python_compiler()
print ' Build :', platform.python_build()
print ' Architecture :', platform.architecture()
print ""
print "Platform information:"
print ' platform :', platform.platform()
print ' system :', platform.system()
print ' node :', platform.node()
print ' release :', platform.release()
print ' version :', platform.version()
print ' machine :', platform.machine()
print ' processor:', platform.processor()
print ""
print "Python path:"
print sys.path
else:
print ""
print "(add -v or --verbose for further information)"
def main(self):
try:
dist = pkg_resources.get_distribution('steelscript')
except pkg_resources.DistributionNotFound:
print "Package not found: 'steelscript'"
print "Check the installation"
sys.exit(1)
e = pkg_resources.AvailableDistributions()
print ""
print "Installed SteelScript Packages"
print "Core packages:"
core_pkgs = [
x for x in e if x.startswith('steel') and 'appfwk' not in x
]
core_pkgs.sort()
for p in core_pkgs:
pkg = pkg_resources.get_distribution(p)
print ' %-40s %s' % (pkg.project_name, pkg.version)
print ""
print "Application Framework packages:"
appfwk_pkgs = [x for x in e if x.startswith('steel') and 'appfwk' in x]
if appfwk_pkgs:
appfwk_pkgs.sort()
for p in appfwk_pkgs:
pkg = pkg_resources.get_distribution(p)
print ' %-40s %s' % (pkg.project_name, pkg.version)
else:
print "None."
print ""
print "Paths to source:"
paths = [os.path.dirname(p) for p in steelscript.__path__]
paths.sort()
for p in paths:
print " %s" % p
if self.options.verbose:
print ""
print "Python information:"
print ' Version :', platform.python_version()
print ' Version tuple:', platform.python_version_tuple()
print ' Compiler :', platform.python_compiler()
print ' Build :', platform.python_build()
print ' Architecture :', platform.architecture()
print ""
print "Platform information:"
print ' platform :', platform.platform()
print ' system :', platform.system()
print ' node :', platform.node()
print ' release :', platform.release()
print ' version :', platform.version()
print ' machine :', platform.machine()
print ' processor:', platform.processor()
print ""
print "Python path:"
print sys.path
else:
print ""
print "(add -v or --verbose for further information)"
def scan(self, groups=None, group_re=None, commit=True, delete=True): # pylint: disable=too-many-branches
"""Walk through all distributions available and register entry points.
Note: This imports pkg_resources.
:param groups: a list of group names to register entry points for.
If None, registers all entry points found.
:param group_re: a regular expression for group names.
Groups matched by the regular expression are appended to `groups`
:type group_re: str or a compiled expression from re.compile
:param commit: If False, performs just a dry run
:param delete: If False, append to existing entry point map
"""
import pkg_resources as pr
pr_env = pr.AvailableDistributions()
pr_env.scan()
groups = groups or []
if group_re:
all_groups = self.scan_all_group_names()
if isinstance(group_re, six.string_types):
group_re = re.compile(group_re)
groups.extend(
{group
for group in all_groups if group_re.match(group)})
if delete:
full_map = {}
if commit:
if groups:
for group in groups:
self._backend.rm_group(group)
else:
self.clear()
else:
full_map = self._backend.epmap.copy()
# ~ for dists in pr_env._distmap.values(): # pylint: disable=protected-access
for dist in pr_env:
# note: in pip 19, the *installing* distribution is part of pr_env but
# pkg_resources.get_distribution() fails on it
try:
dname, emap = self._backend.scan_dist(dist)
except pr.DistributionNotFound:
continue
dmap = full_map.get(dname, {})
if groups:
new_dmap = {
k: v
for k, v in six.iteritems(emap) if k in groups
}
dmap.update(new_dmap)
else:
dmap.update(emap)
# extract entry points that are reserved for other purposes unless excepted
dmap = clean_map(dmap, exceptions=groups)
if commit:
self._backend.write_dist_map(dname, entry_point_map=dmap)
full_map[dname] = [dmap]
return full_map
# Support for pre-entry-point plugins
if egg.has_metadata('trac_plugin.txt'):
env.log.debug('Loading plugin %s from %s', name,
egg.location)
egg.activate()
for module in egg.get_metadata_lines(
'trac_plugin.txt'):
if load_module(module):
modules.append(module)
if modules:
enable_modules(egg.location, modules)
else:
# setuptools < 0.6
distributions = pkg_resources.AvailableDistributions([plugins_dir] \
+ sys.path)
for name in distributions:
egg = distributions[name][0]
modules = []
if egg.metadata.has_metadata(TRAC_META):
egg.install_on()
for module in egg.metadata.get_metadata_lines(TRAC_META):
if load_module(module):
modules.append(module)
if modules:
enable_modules(egg.path, modules)
elif os.path.exists(plugins_dir) and os.listdir(plugins_dir):
env.log.warning('setuptools is required for plugin deployment')
