def test_package_version() -> None: """Assert that version number parsed from pyproject.toml matches version number of installed package obtained by importlib.metadata. """ assert version("inboard") == settings.version assert metadata("inboard")["name"] == settings.name == "inboard" assert metadata("inboard")["summary"] == settings.description
def fetch_module_metadata(distname: str) -> Optional[Dict[str, str]]: """Attempt to retrieve name, version, contact email & url for a package. Parameters ---------- distname : str Name of a distribution. Note: this must match the *name* of the package in the METADATA file... not the name of the module. Returns ------- package_info : dict or None A dict with keys 'name', 'version', 'email', and 'url'. Returns None of the distname cannot be found. """ try: meta = importlib_metadata.metadata(distname) except importlib_metadata.PackageNotFoundError: return None return { 'name': meta.get('Name'), 'version': meta.get('Version'), 'email': meta.get('Author-Email') or meta.get('Maintainer-Email'), 'url': meta.get('Home-page') or meta.get('Download-Url'), }
def fetch_module_metadata(dist: Union[Distribution, str]) -> Dict[str, str]: """Attempt to retrieve name, version, contact email & url for a package. Parameters ---------- distname : str or Distribution Distribution object or name of a distribution. If a string, it must match the *name* of the package in the METADATA file... not the name of the module. Returns ------- package_info : dict A dict with metadata about the package Returns None of the distname cannot be found. """ if isinstance(dist, Distribution): meta = dist.metadata else: try: meta = importlib_metadata.metadata(dist) except importlib_metadata.PackageNotFoundError: return {} return { 'package': meta.get('Name', ''), 'version': meta.get('Version', ''), 'summary': meta.get('Summary', ''), 'url': meta.get('Home-page') or meta.get('Download-Url', ''), 'author': meta.get('Author', ''), 'email': meta.get('Author-Email') or meta.get('Maintainer-Email', ''), 'license': meta.get('License', ''), }
def show_help(self) -> None: try: pkg_metadata = dict(metadata.metadata(speedwagon.__name__)) webbrowser.open_new(pkg_metadata['Home-page']) except metadata.PackageNotFoundError as error: self.log_manager.warning( f"No help link available. Reason: {error}")
def _set_environ_for_briefcase(): package = sys.modules["__main__"].__package__ if package and "Briefcase-Version" in metadata.metadata(package): if sys.platform == "linux": # Use bundled tesseract binary with resources.as_file(resources.files("normcap")) as normcap_path: tesseract_path = normcap_path.parent.parent / "bin" / "tesseract" os.environ["TESSERACT_CMD"] = str(tesseract_path.resolve()) if sys.platform == "darwin": # Use bundled tesseract binary with resources.as_file(resources.files("normcap")) as normcap_path: tesseract_path = ( normcap_path.parent.parent / "app_packages" / "tesseract" ) os.environ["TESSERACT_CMD"] = str(tesseract_path.resolve()) elif sys.platform == "win32": with resources.as_file( resources.files("normcap.resources") ) as resource_path: # Add openssl shipped with briefcase package to path openssl_path = resource_path / "openssl" os.environ["PATH"] += os.pathsep + str(openssl_path.resolve()) # Use bundled tesseract binary tesseract_path = resource_path / "tesseract" / "tesseract.exe" os.environ["TESSERACT_CMD"] = str(tesseract_path.resolve()) os.environ["TESSERACT_VERSION"] = "5.0.0"
def about(file: typing.TextIO = None) -> None: f"""Print information about the package ``> python -m {__package__}.about`` Args: file: Output stream (Defaults to stdout) """ metadata = importlib_metadata.metadata(__package__) # type: ignore print(f"# {metadata['Name']}", file=file) print(f"{metadata['Summary']}", file=file) print(f"{metadata['Home-page']}", file=file) name_width = 24 versions = {} versions["platform"] = platform.platform(aliased=True) versions[__package__] = __version__ versions["python"] = sys.version[0:5] for req in importlib_metadata.requires(__package__): # type: ignore name = re.split("[; =><]", req)[0] try: versions[name] = importlib_metadata.version(name) # type: ignore except Exception: # pragma: no cover pass print(file=file) print("# Configuration", file=file) for name, vers in versions.items(): print(name.ljust(name_width), vers, file=file) print(file=file)
def update_data(data_ext, data_rep, pkg): """Update the entry point data with current install state. This update is IN PLACE for both data_ext and data_rep. Uses 'pkg' as the main key for associating the data with the relevant package. """ eps_ext = ilmd.entry_points().get("flake8.extension", {}) eps_rep = ilmd.entry_points().get("flake8.report", {}) try: version = canonicalize_version(ilmd.version(pkg)) summary = ilmd.metadata(pkg).get("Summary") except ilmd.PackageNotFoundError: version = canonicalize_version("0.0") summary = "[no summary]" for data, eps in zip((data_ext, data_rep), (eps_ext, eps_rep)): data.update( { pkg: { "version": version, "summary": summary, "eps": { ep.name: { "module": (val := ep.value.partition(":"))[0], "callable": val[2], } for ep in eps }, } } )
def dist(name, target=None): # TODO: implement target=None or path to blah blah... """ DESCRIPTION: Use this function to get some info about a distribution package PARAM: name: the distribution name, example: "wheel" RETURN: A dict with these keys: name, author, author_email, description, home_page, maintainer, maintainer_email, version All values are strings. """ metadata_cache = None try: metadata_cache = dist_info.metadata(name) except Exception: pass keys = (("author", "Author"), ("author_email", "Author-email"), ("description", "Summary"), ("home_page", "Home-page"), ("maintainer", "Maintainer"), ("maintainer_email", "Maintainer-email"), ("version", "Version")) data = None if metadata_cache: data = {"name": name} for item in keys: if item[1] in metadata_cache: data[item[0]] = metadata_cache[item[1]] return data
def _check_requirement(requirement_string): # type: (str) -> bool import packaging.requirements if sys.version_info >= (3, 8): from importlib import metadata as importlib_metadata else: import importlib_metadata req = packaging.requirements.Requirement(requirement_string) if req.marker and not req.marker.evaluate(): return True try: version = importlib_metadata.version(req.name) metadata = importlib_metadata.metadata(req.name) except importlib_metadata.PackageNotFoundError: return False metadata_extras = metadata.get_all('Provides-Extra') or [] for extra in req.extras: if extra not in metadata_extras: return False if req.specifier: return req.specifier.contains(version) return True
def test_as_json_egg_info(self): md = metadata('egginfo-pkg').json assert 'name' in md assert md['keywords'] == ['sample', 'package'] desc = md['description'] assert desc.startswith('Once upon a time\nThere was') assert len(md['classifier']) == 2
def _add_to_installed(distname, enabled, npe_version=1): norm_name = normalized_name(distname or '') if distname: try: meta = metadata(distname) except PackageNotFoundError: self.refresh_state = RefreshState.OUTDATED return # a race condition has occurred and the package is uninstalled by another thread if len(meta) == 0: # will not add builtins. return self.already_installed.add(norm_name) else: meta = {} self.installed_list.addItem( PackageMetadata( metadata_version="1.0", name=norm_name, version=meta.get('version', ''), summary=meta.get('summary', ''), home_page=meta.get('url', ''), author=meta.get('author', ''), license=meta.get('license', ''), ), installed=True, enabled=enabled, npe_version=npe_version, )
def test_as_json(self): md = metadata('distinfo-pkg').json assert 'name' in md assert md['keywords'] == ['sample', 'package'] desc = md['description'] assert desc.startswith('Once upon a time\nThere was') assert len(md['requires_dist']) == 2
def test_metadata_for_this_package(self): md = metadata('egginfo-pkg') assert md['author'] == 'Steven Ma' assert md['LICENSE'] == 'Unknown' assert md['Name'] == 'egginfo-pkg' classifiers = md.get_all('Classifier') assert 'Topic :: Software Development :: Libraries' in classifiers
def check_version(requirement_string, extra=''): # type: (str, str) -> bool ''' :param requirement_string: Requirement string :param extra: Extra (eg. test in myproject[test]) ''' import packaging.requirements if sys.version_info >= (3, 8): from importlib import metadata as importlib_metadata else: import importlib_metadata req = packaging.requirements.Requirement(requirement_string) env = {'extra': extra} if req.marker and not req.marker.evaluate(env): return True try: version = importlib_metadata.version(req.name) metadata = importlib_metadata.metadata(req.name) except importlib_metadata.PackageNotFoundError: return False for extra in req.extras: if extra not in (metadata.get_all('Provides-Extra') or []): return False if req.specifier: return req.specifier.contains(version) return True
def __init__(self, parser: argparse.ArgumentParser): parser.add_argument( "--nogui", default=False, action="store_true", help="Don't use the WPIlib simulation gui", ) self.simexts = {} for entry_point in iter_entry_points(group="robotpysimext", name=None): if entry_point.module_name == "halsim_gui": continue try: sim_ext_module = entry_point.load() except ImportError: print(f"WARNING: Error detected in {entry_point}") continue self.simexts[entry_point.name] = sim_ext_module parser.add_argument( f"--{entry_point.name}", default=False, action="store_true", help=metadata(entry_point.dist.project_name)["summary"], )
def running_as_bundled_app() -> bool: """Infer whether we are running as a briefcase bundle""" # https://github.com/beeware/briefcase/issues/412 # https://github.com/beeware/briefcase/pull/425 app_module = sys.modules['__main__'].__package__ metadata = importlib_metadata.metadata(app_module) return 'Briefcase-Version' in metadata
def check_version(requirement_string, extra=''): # type: (str, str) -> bool import packaging.requirements req = packaging.requirements.Requirement(requirement_string) env = { 'extra': extra } if req.marker and not req.marker.evaluate(env): return True try: version = importlib_metadata.version(req.name) metadata = importlib_metadata.metadata(req.name) except importlib_metadata.PackageNotFoundError: return False metadata_extras = metadata.get_all('Provides-Extra') or [] for extra in req.extras: if extra not in metadata_extras: return False if req.specifier: return req.specifier.contains(version) return True
def napari_svg_name(): """the plugin name changes with npe2 to `napari-svg` from `svg`.""" from importlib.metadata import metadata if tuple(metadata('napari-svg')['Version'].split('.')) < ('0', '1', '6'): return 'svg' else: return 'napari-svg'
def get_metadata(*, package_name: str, application_name: str) -> Metadata: """Retrieve metadata for the application. Parameters ---------- pacakge_name : `str` The name of the package (Python namespace). This name is used to look up metadata about the package. application_name : `str` The value to return as the application name (the ``name`` metadata field). Returns ------- metadata : `Metadata` The package metadata as a Pydantic model, suitable for returning as the result of a FastAPI route. Notes ----- ``get_metadata`` integrates extensively with your package's metadata. Typically this metadata is either set in the ``setup.cfg`` or ``setup.py`` file (for setuptools-based applications): version Used as the version metadata. This may be set automatically with ``setuptools_scm``. summary Use as the ``description`` metadata. url Used as the ``documentation_url`` metadata. project_urls, Source code Used as the ``respository_url``. """ if sys.version_info >= (3, 10): pkg_metadata = cast(Message, metadata(package_name)) else: pkg_metadata = metadata(package_name) return Metadata( name=application_name, version=pkg_metadata.get("Version", "0.0.0"), description=pkg_metadata.get("Summary", None), repository_url=get_project_url(pkg_metadata, "Source code"), documentation_url=pkg_metadata.get("Home-page", None), )
def running_as_bundled_app() -> bool: """Infer whether we are running as a briefcase bundle""" # https://github.com/beeware/briefcase/issues/412 # https://github.com/beeware/briefcase/pull/425 # this assumes the name of the app stays "napari" try: return importlib_metadata.metadata("napari").get("App-ID") is not None except importlib_metadata.PackageNotFoundError: """When bundled in another app. Return false to not conflict with napari bundle""" return False
def _get_package_metadata(cls): """Get package metadata for plugin.""" meta = metadata(cls.__name__) return { 'author': meta['Author-email'], 'description': meta['Summary'], 'version': meta['Version'], 'website': meta['Project-URL'], 'license': meta['License'] }
def app_name(): """Get App Name Returns: Name : App Name """ app_name = '' try: app_name = stowMeta.metadata('stowtui')['Name'] except Exception as e: app_name = 'Error: ' + str(e) return app_name
def router(self): """Override this if you want to setup custom swaggerrouter.""" self.logger.info(f'Setting docs at {self.prefix}docs') settings = RapiDocUiSettings(path=f'{self.prefix}docs', theme="light", show_header=False, allow_server_selection=False) description = '' with suppress(Exception): description = metadata.metadata(self.package_name)['Summary'] description = '\n'.join( metadata.metadata(self.package_name).as_string().split( 'Description-Content-Type')[1].split('\n')[1:]) return SwaggerDocs(self.aiohttp_application, title=self.package_name, version=self.version['raw'], description=description, components=self.package_directory / 'openapi.yml', swagger_ui_settings=settings, request_key='payload')
def Author(): """Get Author From Dist Folder Returns: Author : Author Name """ author = '' try: author = stowMeta.metadata('stowtui')['Author'] except Exception as e: author = 'Error: ' + str(e) return author
def Email(): """Get Author Email From Dist Folder Returns: Email : Author Email """ email = '' try: email = stowMeta.metadata('stowtui')['Author-email'] except Exception as e: email = 'Error: ' + str(e) return email
def handle(self, project: Project, options: argparse.Namespace) -> None: plugins = _all_plugins() echo = project.core.ui.echo if not plugins: echo("No plugin is installed with PDM", err=True) sys.exit(1) echo("Installed plugins:", err=True) for plugin in plugins: metadata = importlib_metadata.metadata(plugin) echo( f"{termui.green(metadata['Name'])} {termui.yellow(metadata['Version'])}" ) if metadata["Summary"]: echo(f" {metadata['Summary']}")
def running_as_bundled_app() -> bool: """Infer whether we are running as a briefcase bundle""" # https://github.com/beeware/briefcase/issues/412 # https://github.com/beeware/briefcase/pull/425 # note that a module may not have a __package__ attribute try: app_module = sys.modules['__main__'].__package__ except AttributeError: return False try: metadata = importlib_metadata.metadata(app_module) except importlib_metadata.PackageNotFoundError: return False return 'Briefcase-Version' in metadata
def about_dialog_box(parent): try: pkg_metadata = dict(metadata.metadata(speedwagon.__name__)) summary = pkg_metadata['Summary'] version = pkg_metadata['Version'] message = f"{speedwagon.__name__.title()}: {version}" \ f"\n" \ f"\n" \ f"{summary}" except metadata.PackageNotFoundError: message = \ f"{speedwagon.__name__.title()}" QtWidgets.QMessageBox.about(parent, "About", message)
def _test_metadata_search_path_inner(): # initialize the DeprecatedModuleFinders # pylint: disable=unused-import import cirq.testing._compat_test_data.module_a try: # importlib.metadata for python 3.8+ # coverage: ignore import importlib.metadata as m except: # coverage: ignore # coverage: ignore # importlib_metadata for python <3.8 m = pytest.importorskip("importlib_metadata") assert m.metadata('flynt')
def get_dist_name(entry_point: importlib_metadata.EntryPoint) -> Optional[str]: dist = getattr(entry_point, "dist", None) if dist is not None: # Python 3.10+ return dist.name match = entry_point.pattern.match(entry_point.value) if not (match and match.group('module')): return None package = match.group('module').split('.')[0] try: metadata = importlib_metadata.metadata(package) except importlib_metadata.PackageNotFoundError: return None else: return metadata.get('name')