def includeReqs(self, reqs, zcml_to_look_for, result, seen, exclude): for req in reqs: pkg = req.project_name if pkg == 'setuptools' or pkg in exclude: continue if req.extras: for extra in req.extras: if (pkg, extra) in seen: continue try: dist = get_provider(req) except: seen.add(pkg) continue DependencyFinder(dist).includableInfo( zcml_to_look_for, result, seen, exclude, (extra,)) else: if pkg in seen: continue try: dist = get_provider(req) except: seen.add(pkg) continue DependencyFinder(dist).includableInfo( zcml_to_look_for, result, seen, exclude)
def is_pil_installed(): pil_req = pkg_resources.Requirement.parse('PIL') try: pkg_resources.get_provider(pil_req) except pkg_resources.DistributionNotFound: return False return True
def package_installed(pkg): """Check if package is installed""" req = pkg_resources.Requirement.parse(pkg) try: pkg_resources.get_provider(req) except pkg_resources.DistributionNotFound: return False else: return True
def pillow_installed(): """Check if Pillow is installed""" pillow_req = pkg_resources.Requirement.parse('Pillow'); try: pkg_resources.get_provider(pillow_req); except pkg_resources.DistributionNotFound: return False; else: return True;
def pillow_installed(): """Check if Pillow is installed""" pillow_req = pkg_resources.Requirement.parse('Pillow') try: pkg_resources.get_provider(pillow_req) except pkg_resources.DistributionNotFound: return False else: return True
def _check_requirement(dependency_string): """Parses a dependency string, and checks if the specified requirement is installed Raises: VersionConflict if the requirement is installed, but with the the wrong version DistributionNotFound if nothing is found to provide the requirement """ req = Requirement.parse(dependency_string) # first check if the markers specify that this requirement needs installing if req.marker is not None and not req.marker.evaluate(): # not required for this environment return get_provider(req)
def _prepare_bootstrap(self): """ Write enough of distribute into the .pex .bootstrap directory so that we can be fully self-contained. """ setuptools = dist_from_egg( self._interpreter.get_location('setuptools')) for fn, content_stream in DistributionHelper.walk_data(setuptools): if fn == 'pkg_resources.py': self._chroot.write( content_stream.read(), os.path.join(self.BOOTSTRAP_DIR, 'pkg_resources.py'), 'resource') libraries = ( 'twitter.common.python', 'twitter.common.python.http', ) for name in libraries: dirname = name.replace('twitter.common.python', '_twitter_common_python').replace('.', '/') provider = get_provider(name) if not isinstance(provider, DefaultProvider): mod = __import__(name, fromlist=['wutttt']) provider = ZipProvider(mod) for fn in provider.resource_listdir(''): if fn.endswith('.py'): self._chroot.write( provider.get_resource_string(name, fn), os.path.join(self.BOOTSTRAP_DIR, dirname, fn), 'resource')
def _prepare_bootstrap(self): # Writes enough of setuptools into the .pex .bootstrap directory so that we can be fully # self-contained. wrote_setuptools = False setuptools = DistributionHelper.distribution_from_path( self._interpreter.get_location('setuptools'), name='setuptools') if setuptools is None: raise RuntimeError('Failed to find setuptools while building pex!') for fn, content_stream in DistributionHelper.walk_data(setuptools): if fn.startswith('pkg_resources') or fn.startswith('_markerlib'): self._chroot.write(content_stream.read(), os.path.join(self.BOOTSTRAP_DIR, fn), 'resource') wrote_setuptools = True if not wrote_setuptools: raise RuntimeError( 'Failed to extract pkg_resources from setuptools. Perhaps pants was linked with an ' 'incompatible setuptools.') libraries = { 'pex': '_pex', } for source_name, target_location in libraries.items(): provider = get_provider(source_name) if not isinstance(provider, DefaultProvider): mod = __import__(source_name, fromlist=['ignore']) provider = ZipProvider(mod) for fn in provider.resource_listdir(''): if fn.endswith('.py'): self._chroot.write(provider.get_resource_string(source_name, fn), os.path.join(self.BOOTSTRAP_DIR, target_location, fn), 'resource')
def _prepare_bootstrap(self): """ Write enough of distribute into the .pex .bootstrap directory so that we can be fully self-contained. """ wrote_setuptools = False setuptools = DistributionHelper.distribution_from_path( self._interpreter.get_location('setuptools')) for fn, content_stream in DistributionHelper.walk_data(setuptools): if fn == 'pkg_resources.py' or fn.startswith('_markerlib'): self._chroot.write(content_stream.read(), os.path.join(self.BOOTSTRAP_DIR, fn), 'resource') wrote_setuptools = True if not wrote_setuptools: raise RuntimeError( 'Failed to extract pkg_resources from setuptools. Perhaps pants was linked with an ' 'incompatible setuptools.') libraries = ( 'twitter.common.python', 'twitter.common.python.http', ) for name in libraries: dirname = name.replace('twitter.common.python', '_twitter_common_python').replace('.', '/') provider = get_provider(name) if not isinstance(provider, DefaultProvider): mod = __import__(name, fromlist=['wutttt']) provider = ZipProvider(mod) for fn in provider.resource_listdir(''): if fn.endswith('.py'): self._chroot.write(provider.get_resource_string(name, fn), os.path.join(self.BOOTSTRAP_DIR, dirname, fn), 'resource')
def _check_module_path(self): # If ferenda is imported, and the working directory of the # process is then changed (with os.cwd()), this can cause # problems with the pkg_resources API, since that module might # use relative paths for the location of resources, and # changing the working directory causes these relative paths # to be invalid wrt the new working directory. This seem to be # a problem with py2 only, since on py3 the absolute path for # each loaded module is stored in sys.modules which # pkg_resources uses. # # This method tries to detect the problem and correct it if # possible. if self.use_pkg_resources: module_path = pkg_resources.get_provider("ferenda").module_path if not os.path.exists(module_path) and not os.path.isabs(module_path): # There appears to be no simple way of determining the # "true" path of where ferenda is installed. But if # os.environ["FERENDA_HOME"] is defined we can rely on # that. Then we directly muck with sys.modules to # record the absolute path to the module. This might # not be legal... NB: This should only happen in # development mode, not with an installed ferenda # package, and only on py2. if "FERENDA_HOME" in os.environ: truepath = (os.environ["FERENDA_HOME"] + os.sep + module_path + os.sep + "__init__.py") sys.modules["ferenda"].__file__ = truepath else: raise ResourceNotFound("pkg_resources internal variable module_path is a relative path (%s). No such path exists relative to %s" % (module_path, os.getcwd()))
def __init__(self, allowed_template): self.allowed_template = allowed_template self.provider = get_provider(self.package_name) self.manager = ResourceManager() self.src_mock = mock.MagicMock( spec='jinja2.loaders.PackageLoader.get_source', autospec=True) self.src_mock.side_effect = self.template_source
def load_config(config_path): if config_path.startswith('/'): return open(config_path) if '=' in config_path: key, value = config_path.split('=', 1) key = key.strip() value = value.strip() try: json.loads(value) except ValueError: value = json.dumps(value) # convert key=value to key: value # key:value syntax is already taken by package loader return ['{key}: {value}'.format(key=key, value=value)] if ':' in config_path: package, relative_path = config_path.split(':', 1) resource_manager = pkg_resources.ResourceManager() provider = pkg_resources.get_provider(package) return provider.get_resource_stream(resource_manager, relative_path) return open(config_path)
def get_package_loader(self, package, package_path): from pkg_resources import DefaultProvider, ZipProvider, \ ResourceManager, get_provider loadtime = datetime.utcnow() provider = get_provider(package) manager = ResourceManager() filesystem_bound = isinstance(provider, DefaultProvider) zip_bound = isinstance(provider, ZipProvider) def loader(path): if path is None: return None, None path = posixpath.join(package_path, path) if not provider.has_resource(path): return None, None basename = posixpath.basename(path) if filesystem_bound: return basename, self._opener( provider.get_resource_filename(manager, path)) file_size = 0 if zip_bound: zip_path = "/".join([ package.replace(".", "/"), path ]) file_zip_info = provider.zipinfo.get(zip_path) if file_zip_info: file_size = file_zip_info.file_size return basename, lambda: ( provider.get_resource_stream(manager, path), loadtime, file_size ) return loader
def do_instinfo(self, subcmd, opts): """ ${cmd_name}: Get some information about the yt installation ${cmd_usage} ${cmd_option_list} """ import pkg_resources yt_provider = pkg_resources.get_provider("yt") path = os.path.dirname(yt_provider.module_path) print print "yt module located at:" print " %s" % (path) if "site-packages" not in path: vc_type = _get_vcs_type(path) vstring = _vcs_identifier[vc_type](path) print print "The current version of the code is:" print print "---" print vstring print "---" print print "This installation CAN be automatically updated." if opts.update_source: _vcs_updater[vc_type](path) print "Updated successfully."
def installFonts(file_name): """ Install the specified font file to this system. """ if isinstance(pkg_resources.get_provider('pyfiglet'), pkg_resources.ZipProvider): # Figlet is installed using a zipped resource - don't try to upload to it. location = SHARED_DIRECTORY else: # Figlet looks like a standard directory - so lets use that to install new fonts. location = pkg_resources.resource_filename('pyfiglet', 'fonts') print("Installing {} to {}".format(file_name, location)) # Make sure the required destination directory exists if not os.path.exists(location): os.makedirs(location) # Copy the font definitions - unpacking any zip files as needed. if os.path.splitext(file_name)[1].lower() == ".zip": # Ignore any structure inside the ZIP file. with zipfile.ZipFile(file_name) as zip_file: for font in zip_file.namelist(): font_file = os.path.basename(font) if not font_file: continue with zip_file.open(font) as src: with open(os.path.join(location, font_file), "wb") as dest: shutil.copyfileobj(src, dest) else: shutil.copy(file_name, location)
def load_kernel(package, kernel_name): kernel_path = Path( pkg_resources.get_provider(package).get_resource_filename( __name__, '{}.cl'.format(kernel_name))) with kernel_path.open() as f: kernel_source = ''.join(f.readlines()) return kernel_source
def __init__(self): builder = gtk.Builder() if hasattr(sys ,'frozen'): from blogger_update_metatags import resources data = resources.GUI_XML else: try: import pkgutil data = pkgutil.get_data(__name__, 'gui.xml') except ImportError: from pkg_resources import get_provider, ResourceManager data = get_provider(__name__).get_resource_string(ResourceManager(), 'gui.xml') builder.add_from_string(data) builder.connect_signals(self) for obj in builder.get_objects(): setattr(self, gtk.Buildable.get_name(obj), obj) if os.access(DEFAULT_CONFIG_FILE, os.R_OK): self.filechooserbutton.set_filename(DEFAULT_CONFIG_FILE) self.treeview_log.append_column(gtk.TreeViewColumn(None, gtk.CellRendererPixbuf(), stock_id=0)) self.treeview_log.append_column(gtk.TreeViewColumn(None, gtk.CellRendererText(), text=1)) self.dialog.show_all() logger.addHandler(GtkListStoreHandler(self.liststore_log))
def _package_name(self): pkg_provider = pkg_resources.get_provider(self.modname) module_path = self.modname.replace('.', os.sep) is_package = pkg_provider.module_path.endswith(module_path) if is_package: return self.modname return self.modname.rsplit('.', 1)[0]
def get_package_loader(self, package, package_path): from pkg_resources import DefaultProvider, ResourceManager, \ get_provider loadtime = datetime.utcnow() provider = get_provider(package) manager = ResourceManager() filesystem_bound = isinstance(provider, DefaultProvider) def loader(path): if path is None: return None, None path = posixpath.join(package_path, path) if not provider.has_resource(path): return None, None basename = posixpath.basename(path) if filesystem_bound: return basename, self._opener( provider.get_resource_filename(manager, path)) s = provider.get_resource_string(manager, path) return basename, lambda: ( BytesIO(s), loadtime, len(s) ) return loader
def getModuleFormat(self,importModulePath): provider = pkg_resources.get_provider(importModulePath) format = 'Null' if isinstance(provider, pkg_resources.EggProvider): format = 'Egg' if isinstance(provider, pkg_resources.DefaultProvider): format = 'File' if isinstance(provider, pkg_resources.ZipProvider): format = 'Zip' return format
def add_source(self, name, package_name, directory, cache_max_age=None): """ Add a static files source directory, optionally associated with a python package. :param name: The (unique) name used to identify this source. :param package_name: The name of the python package containing the files :param directory: Path to the directory containing the static files. Should be relative if package_name is specified, otherwise absolute. :param cache_max_age: Optional duration in seconds for the Cache-Control max-age header. If omitted the default value is used """ if name in self.sources: raise ValueError("StaticFiles source %r is already used" % (name, )) if package_name: map_path = get_provider(package_name).get_resource_filename else: def map_path(resource_manager, path): return path static_root = map_path(self.resource_manager, directory) if not isdir(static_root): raise ValueError("%r is not a directory" % (static_root, )) cache_max_age = (self.cache_max_age if cache_max_age is None else cache_max_age) self.sources[name] = (map_path, directory, cache_max_age)
def includableInfo(self, zcml_to_look_for): """Return the packages in the dependencies which are includable. zcml_to_look_for - a list of zcml filenames we are looking for Returns a dictionary with the include candidates as keys, and lists of dotted names of packages that contain the include candidates as values. """ result = ZCMLInfo(zcml_to_look_for) for req in self.context.requires(): dist_manager = DistributionManager(get_provider(req)) for dotted_name in dist_manager.dottedNames(): try: module = resolve(dotted_name) except ImportError as exc: logging.getLogger("z3c.autoinclude").warn( "resolve(%r) raised import error: %s" % (dotted_name, exc)) continue for candidate in zcml_to_look_for: candidate_path = os.path.join( os.path.dirname(module.__file__), candidate) if os.path.isfile(candidate_path): result[candidate].append(dotted_name) return result
def includableInfo(self, zcml_to_look_for): """Return the packages in the dependencies which are includable. zcml_to_look_for - a list of zcml filenames we are looking for Returns a dictionary with the include candidates as keys, and lists of dotted names of packages that contain the include candidates as values. """ result = ZCMLInfo(zcml_to_look_for) for req in self.context.requires(): dist_manager = DistributionManager(get_provider(req)) for dotted_name in dist_manager.dottedNames(): try: module = resolve(dotted_name) except ImportError as exc: logger.warning( "resolve(%r) raised import error: %s" % (dotted_name, exc)) continue module_file = getattr(module, '__file__', None) if module_file is None: logger.warning( "%r has no __file__ attribute" % dotted_name) continue for candidate in zcml_to_look_for: candidate_path = os.path.join( os.path.dirname(module_file), candidate) if os.path.isfile(candidate_path): result[candidate].append(dotted_name) return result
def _check_module_path(self): # If ferenda is imported, and the working directory of the # process is then changed (with os.cwd()), this can cause # problems with the pkg_resources API, since that module might # use relative paths for the location of resources, and # changing the working directory causes these relative paths # to be invalid wrt the new working directory. This seem to be # a problem with py2 only, since on py3 the absolute path for # each loaded module is stored in sys.modules which # pkg_resources uses. # # This method tries to detect the problem and correct it if # possible. if self.use_pkg_resources: module_path = pkg_resources.get_provider("ferenda").module_path if not os.path.exists(module_path) and not os.path.isabs( module_path): # There appears to be no simple way of determining the # "true" path of where ferenda is installed. But if # os.environ["FERENDA_HOME"] is defined we can rely on # that. Then we directly muck with sys.modules to # record the absolute path to the module. This might # not be legal... NB: This should only happen in # development mode, not with an installed ferenda # package, and only on py2. if "FERENDA_HOME" in os.environ: truepath = (os.environ["FERENDA_HOME"] + os.sep + module_path + os.sep + "__init__.py") sys.modules["ferenda"].__file__ = truepath else: raise ResourceNotFound( "pkg_resources internal variable module_path is a relative path (%s). No such path exists relative to %s" % (module_path, os.getcwd()))
def set_project_info(): """Set project information from setup tools installation.""" # CUSTOMIZE THIS VALUE FOR YOUR OWN INSTALLATION base_url = 'https://slack-tableflip.herokuapp.com' # Get app info from the dist app_name = 'slack_tableflip' provider = get_provider(app_name) return { 'name': app_name, 'name_full': 'EM Slack Tableflip', 'author_url': 'http://www.erinmorelli.com', 'github_url': 'https://github.com/ErinMorelli/em-slack-tableflip', 'version': '1.5', 'version_int': 1.5, 'package_path': provider.module_path, 'copyright': '2015-{0}'.format(str(date.today().year)), 'client_secret': os.environ['SLACK_CLIENT_SECRET'], 'client_id': os.environ['SLACK_CLIENT_ID'], 'base_url': base_url, 'oauth_url': 'https://slack.com/oauth/authorize', 'auth_url': '{0}/authenticate'.format(base_url), 'user_url': '{0}/validate'.format(base_url), 'team_url': '{0}/authorize'.format(base_url), 'team_scope': [ 'commands' ], 'user_scope': [ 'chat:write:bot', 'chat:write:user', 'identify' ] }
def get_package_loader(self, package, package_path): from pkg_resources import DefaultProvider, ResourceManager, get_provider loadtime = datetime.utcnow() provider = get_provider(package) manager = ResourceManager() filesystem_bound = isinstance(provider, DefaultProvider) def loader(path): if path is None: return None, None path = posixpath.join(package_path, path) if not provider.has_resource(path): return None, None basename = posixpath.basename(path) if filesystem_bound: return ( basename, self._opener(provider.get_resource_filename(manager, path)), ) s = provider.get_resource_string(manager, path) return basename, lambda: (BytesIO(s), loadtime, len(s)) return loader
def update_periods_file(): mapping = generate_mapping() path = get_provider(__name__).module_path with open(pjoin(path, "periods.yaml"), "wb") as fd: fd.write(dump(mapping)) print "Periods file updated with %i entries" % len(mapping)
def __init__(self): """ Initialize CLI. """ self.startup = time.time() self.LOG = pymagic.get_class_logger(self) # Get version number self.version = self.VERSION if not self.version: # Take version from package provider = pkg_resources.get_provider(__name__) pkg_info = provider.get_metadata("PKG-INFO") if not pkg_info: pkg_info = "Version: 0.0.0\n" try: # Development setup pkg_path = os.path.join( __file__.split(__name__.replace( '.', os.sep))[0], # containing path __name__.split(".")[0] # package name ) if os.path.exists(pkg_path + ".egg-info"): pkg_path += ".egg-info" else: pkg_path = glob.glob(pkg_path + "-*-py%d.%d.egg-info" % sys.version_info[:2]) if len(pkg_path) == 1: pkg_path = pkg_path[0] else: self.LOG.warn("Found %d candidate versions" % len(pkg_path)) pkg_path = None if pkg_path: with closing(open(os.path.join(pkg_path, "PKG-INFO"))) as handle: pkg_info = handle.read() else: self.LOG.warn("Software version cannot be determined!") except IOError: self.LOG.warn("Software version cannot be determined!") pkg_info = dict( line.split(": ", 1) for line in pkg_info.splitlines() if ": " in line) self.version = pkg_info.get("Version", "DEV") self.args = None self.options = None self.return_code = 0 self.parser = OptionParser( "%prog [options] " + self.ARGS_HELP + "\n\n" "%prog " + self.version + (", " + self.COPYRIGHT if self.COPYRIGHT else "") + "\n\n" + textwrap.dedent(self.__doc__.rstrip()).lstrip('\n') + '\n'.join(self.ADDITIONAL_HELP) + "\n\nFor more details, see the full documentation at" + "\n\n https://pyrocore.readthedocs.io/", version="%prog " + self.version)
def get_version_from_pkg_resources(package): try: requirement = pkg_resources.Requirement.parse(package) provider = pkg_resources.get_provider(requirement) return provider.version except Exception as err: print(f"get_version_from_pkg_resources: {err}") return None
def _get_provider(self): if self._provider is None: try: requirement = pkg_resources.Requirement.parse(self.package) self._provider = pkg_resources.get_provider(requirement) except pkg_resources.DistributionNotFound: pass return self._provider
def __init__(self, package_name, package_path = 'templates', encoding = 'utf-8'): from pkg_resources import DefaultProvider, ResourceManager, get_provider provider = get_provider(package_name) self.encoding = encoding self.manager = ResourceManager() self.filesystem_bound = isinstance(provider, DefaultProvider) self.provider = provider self.package_path = package_path
def enclose_package_path_exists(package_name): """ Returns a `path_exists` method that searches within the specified package """ # NOTE: I don't really like the `enclose_...` name, if anyone wants to # refactor this name, please feel free provider = pkg_resources.get_provider(package_name) return provider.has_resource
def __init__(self, package_name, package_path='templates', encoding='utf-8'): provider = get_provider(package_name) self.encoding = encoding self.manager = ResourceManager() self.filesystem_bound = isinstance(provider, DefaultProvider) self.provider = provider self.package_path = package_path
def list_children(self): provider = pkg_resources.get_provider(self.mod_name) children = [] for f in provider.resource_listdir('.'): if f.endswith('.py'): children.append(f[:-3]) elif '.' not in f and provider.has_resource(os.path.join(f, '__init__.py')): children.append(f) return sorted(set(children))
def load_resource(self, rp=None, package='stackdio'): """ Takes a relative path `rp`, and attempts to pull the full resource path using pkg_resources. """ provider = get_provider(package) if rp is None: return os.path.dirname(provider.module_path) return provider.get_resource_filename(ResourceManager(), rp)
def load_templates(self): for package_name in self.modules: try: pkg = self.packages[package_name] = {} pkg['provider'] = get_provider(package_name) pkg['fs_bound'] = isinstance(pkg['provider'], DefaultProvider) except Exception as e: trace = str(traceback.format_exc()) log.error("Can't import module %s\n%s" % (str(e), trace))
def __init__(self, module, env=None): """Initialize the Environment object :param module: The Module that serves as the basis for this botoweb application :param env: Optional environment file that overrides any settings in our config """ self.module = module self._client_connection = None if not env: env = os.environ.get("BOTO_WEB_ENV") self.env = env # Config setup self.config = Config() self.config.env = self self.dist = get_provider(self.module) self.mgr = ResourceManager() if self.dist.has_resource("conf"): self.config.update(self.get_config("conf")) if env and os.path.exists(self.env): log.info("Loading environment: %s" % self.env) self.config.update(yaml.load(open(self.env, "r"))) # Set up the DB shortcuts if not self.config.has_key("DB"): self.config['DB'] = { "db_type": self.config.get("DB", "db_type", "SimpleDB"), "db_user": self.config.get("Credentials", "aws_access_key_id"), "db_passwd": self.config.get("Credentials", "aws_secret_access_key") } if self.config.has_key("auth_db"): self.config['DB']['User'] = {"db_name": self.config['auth_db']} if self.config.has_key("default_db"): self.config['DB']['db_name'] = self.config["default_db"] if self.config.has_key("session_db"): self.config['DB']['Session'] = { 'db_name': self.config["session_db"] } # Bootstrap importing all db_classes for XMLize if self.config['botoweb'].has_key("handlers"): for handler in self.config['botoweb']['handlers']: if handler.has_key("db_class"): try: db_class = find_class(handler['db_class']) except: log.exception("Could not load class: %s" % handler['db_class']) db_class = None if db_class: xmlize.register(db_class)
def test_redocjs_lib_is_copied(run_sphinx, tmpdir): outdir = tmpdir.join('out') extdir = py.path.local( pkg_resources.get_provider('sphinxcontrib.redoc').module_path) run_sphinx() assert outdir.join('_static', 'redoc.js').check() assert outdir.join('_static', 'redoc.js').computehash() \ == extdir.join('redoc.js').computehash()
def setUp(self): self.port = random.randrange(10000, 20000) provider = pkg_resources.get_provider(__name__) demo_config_path = provider.get_resource_filename(None, 'demo_config.py') self.process = subprocess.Popen([ os.path.join(os.path.dirname(sys.executable), 'fake_jenkins'), '0.0.0.0', str(self.port) ], env={'FAKE_JENKINS_CONFIG_FILE': demo_config_path})
def __init__(self, package_name, package_path="templates", encoding="utf-8", get_language=None): from pkg_resources import DefaultProvider, ResourceManager, get_provider provider = get_provider(package_name) self.encoding = encoding self.manager = ResourceManager() self.filesystem_bound = isinstance(provider, DefaultProvider) self.provider = provider self.package_path = package_path self.get_language = get_language or (lambda: [])
def _prepare_bootstrap(self): """ Write enough of distribute and pip into the .pex .bootstrap directory so that we can be fully self-contained. """ bare_env = pkg_resources.Environment() pip_req = pkg_resources.Requirement.parse('pip>=1.1') distribute_req = pkg_resources.Requirement.parse('distribute>=0.6.24') pip_dist = distribute_dist = None for dist in DistributionHelper.all_distributions(sys.path): if dist in pip_req and bare_env.can_add(dist): pip_dist = dist if dist in distribute_req and bare_env.can_add(dist): distribute_dist = dist if pip_dist and distribute_dist: break if not pip_dist: raise DistributionNotFound('Could not find pip!') if not distribute_dist: raise DistributionNotFound('Could not find distribute!') PEX.debug('Writing .bootstrap library.') for fn, content in DistributionHelper.walk_data(pip_dist): if fn.startswith('pip/'): # PEX.debug('BOOTSTRAP: Writing %s' % fn) self._chroot.write(content, os.path.join(self.BOOTSTRAP_DIR, fn), 'resource') for fn, content in DistributionHelper.walk_data(distribute_dist): if fn.startswith('pkg_resources.py') or fn.startswith('setuptools'): # PEX.debug('BOOTSTRAP: Writing %s' % fn) self._chroot.write(content, os.path.join(self.BOOTSTRAP_DIR, fn), 'resource') libraries = ( 'twitter.common.dirutil', 'twitter.common.collections', 'twitter.common.contextutil', 'twitter.common.lang', 'twitter.common.python' ) for name in libraries: dirname = name.replace('.', '/') provider = pkg_resources.get_provider(name) if not isinstance(provider, pkg_resources.DefaultProvider): mod = __import__(name, fromlist=['wutttt']) provider = pkg_resources.ZipProvider(mod) for fn in provider.resource_listdir(''): if fn.endswith('.py'): # PEX.debug('BOOTSTRAP: Writing %s' % os.path.join(dirname, fn)) self._chroot.write(provider.get_resource_string(name, fn), os.path.join(self.BOOTSTRAP_DIR, dirname, fn), 'resource') for initdir in ('twitter', 'twitter/common'): self._chroot.write( b"__import__('pkg_resources').declare_namespace(__name__)", os.path.join(self.BOOTSTRAP_DIR, initdir, '__init__.py'), 'resource')
def __init__(self, package_name, package_path="templates", encoding="utf-8"): from pkg_resources import DefaultProvider from pkg_resources import get_provider from pkg_resources import ResourceManager provider = get_provider(package_name) self.encoding = encoding self.manager = ResourceManager() self.filesystem_bound = isinstance(provider, DefaultProvider) self.provider = provider self.package_path = package_path
def getTemplate(cls, fname): current_module = sys.modules[__name__] provider = get_provider(current_module.__package__) manager = ResourceManager() p = "/".join(['templates', fname]) if not provider.has_resource(p): raise Exception("Template not found: %s", fname) return provider.get_resource_string(manager, p)
def get_yt_version(): try: from yt.__hg_version__ import hg_version return hg_version except ImportError: pass import pkg_resources yt_provider = pkg_resources.get_provider("yt") path = os.path.dirname(yt_provider.module_path) version = get_hg_version(path)[:12] return version
def __init__(self, package, path=''): """ Initialize package resource provider. :param string package: python package/module name or object :param string path: name of a resource relative to the package """ self.package = package self.path = path self._manager = _manager self._provider = pkg_resources.get_provider(package)
def get_example_data(dataset_name): """ This is a smart package loader that locates text files inside our package :param dataset_name: :return: """ provider = get_provider('ebu_tt_live') manager = ResourceManager() source = provider.get_resource_string(manager, 'example_data/'+dataset_name) return source
def __init__(self, package_name, package_path='templates', encoding='utf-8'): from pkg_resources import DefaultProvider, ResourceManager, \ get_provider provider = get_provider(package_name) self._encoding = encoding self._manager = ResourceManager() self._filesystem_bound = isinstance(provider, DefaultProvider) self._provider = provider self._package_path = package_path
def __call__(self, component): """ Load a Jinja2 Environment for a component. """ package_path = join(self.templates_path, component) provider = get_provider(self.package_name) if not provider.resource_isdir(package_path): return Environment(loader=EmptyLoader()) return Environment(loader=PackageLoader(self.package_name, package_path), undefined=StrictUndefined)
def _get_version_from_pkg_resources(self): """Get the version of the package from the pkg_resources record associated with the package.""" try: requirement = pkg_resources.Requirement.parse(self.package) provider = pkg_resources.get_provider(requirement) return provider.version except pkg_resources.DistributionNotFound: # The most likely cause for this is running tests in a tree # produced from a tarball where the package itself has not been # installed into anything. Revert to setup-time logic. return "8.0.0.20"