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')
