def get_recursive_dependencies(distro,
package_names,
excludes=None,
limit_depth=None):
excludes = set(excludes or [])
dependencies = set([])
walker = DependencyWalker(distro)
# redirect all stderr output to logger
stderr = sys.stderr
sys.stderr = CustomLogger()
try:
for pkg_name in package_names:
try:
dependencies |= walker.get_recursive_depends(
pkg_name, ['buildtool', 'build', 'run', 'test'],
ros_packages_only=True,
ignore_pkgs=dependencies | excludes,
limit_depth=limit_depth)
except AssertionError as e:
raise RuntimeError(
"Failed to fetch recursive dependencies of package '%s': %s"
% (pkg_name, e))
finally:
sys.stderr = stderr
dependencies -= set(package_names)
return dependencies
def get_recursive_dependencies(distro, package_names, excludes=None, limit_depth=None):
excludes = set(excludes or [])
dependencies = set([])
walker = DependencyWalker(distro)
# redirect all stderr output to logger
stderr = sys.stderr
sys.stderr = CustomLogger()
try:
for pkg_name in package_names:
try:
dependencies |= walker.get_recursive_depends(pkg_name, ['buildtool', 'build', 'run', 'test'], ros_packages_only=True, ignore_pkgs=dependencies | excludes, limit_depth=limit_depth)
except AssertionError as e:
raise RuntimeError("Failed to fetch recursive dependencies of package '%s': %s" % (pkg_name, e))
finally:
sys.stderr = stderr
dependencies -= set(package_names)
return dependencies
# Construct a dictionary where keys are repository names and values are a list
# of the missing dependencies for that repository
blocked_repos = {}
unblocked_repos = set()
total_blocking_repos = set()
for repository_name in repo_names:
repo = prev_distro_file.repositories[repository_name]
release_repo = repo.release_repository
package_dependencies = set()
packages = release_repo.package_names
# Accumulate all dependencies for those packages
for package in packages:
recursive_dependencies = dependency_walker.get_recursive_depends(
package, ['build', 'run', 'buildtool'], ros_packages_only=True,
limit_depth=args.depth)
package_dependencies = package_dependencies.union(
recursive_dependencies)
# For all package dependencies, check if they are released yet
unreleased_pkgs = package_dependencies.difference(
current_package_names)
# remove the packages which this repo provides.
unreleased_pkgs = unreleased_pkgs.difference(packages)
# Now get the repositories for these packages.
blocking_repos = set(prev_distro_file.release_packages[pkg].repository_name
for pkg in unreleased_pkgs)
if len(blocking_repos) == 0:
unblocked_repos.add(repository_name)
else:
# print("Fetching deps for: ", mp)
deps = list(set(metapackages[mp].run_depends))
mp_sets[mp] = set([])
for dep in deps:
mp_sets[mp].update(set([dep.name]))
if dep.name in keys:
continue
# print(" ", dep.name)
previous_pkgs = set([])
for mp_, mp_set in mp_sets.items():
if mp == mp_:
continue
previous_pkgs.update(mp_set)
mp_sets[mp].update(dw.get_recursive_depends(
dep.name,
['buildtool', 'build', 'run'],
ros_packages_only=True,
ignore_pkgs=['ros_comm_msgs'] + list(previous_pkgs)
))
# print(" => ", len(mp_sets[mp]))
# Repos by package
repos_by_package = {}
repo_mstatuses = {}
for name, repo in dist_file.repositories.items():
if name == 'geometry_angles_utils':
indigo_name = 'angles'
else:
indigo_name = name
if not repo.release_repository:
continue
if indigo_name not in indigo_dist_file.repositories:
def _get_blocked_releases_info(config_url, rosdistro_name, repo_names=None):
import rosdistro
from rosdistro.dependency_walker import DependencyWalker
from catkin_pkg.package import InvalidPackage, parse_package_string
prev_rosdistro_name = None
config = get_config_index(config_url)
index = rosdistro.get_index(config.rosdistro_index_url)
valid_rosdistro_names = list(index.distributions.keys())
valid_rosdistro_names.sort()
if rosdistro_name is None:
rosdistro_name = valid_rosdistro_names[-1]
print('Checking packages for "%s" distribution' % rosdistro_name)
# skip distributions with a different type if the information is available
distro_type = index.distributions[rosdistro_name].get('distribution_type')
if distro_type is not None:
valid_rosdistro_names = [
n for n in valid_rosdistro_names
if distro_type == index.distributions[n].get('distribution_type')]
# Find the previous distribution to the current one
try:
i = valid_rosdistro_names.index(rosdistro_name)
except ValueError:
print('Distribution key not found in list of valid distributions.', file=sys.stderr)
exit(-1)
if i == 0:
print('No previous distribution found.', file=sys.stderr)
exit(-1)
prev_rosdistro_name = valid_rosdistro_names[i - 1]
cache = rosdistro.get_distribution_cache(index, rosdistro_name)
distro_file = cache.distribution_file
prev_cache = rosdistro.get_distribution_cache(index, prev_rosdistro_name)
prev_distribution = rosdistro.get_cached_distribution(
index, prev_rosdistro_name, cache=prev_cache)
prev_distro_file = prev_cache.distribution_file
dependency_walker = DependencyWalker(prev_distribution)
if repo_names is None:
# Check missing dependencies for packages that were in the previous
# distribution that have not yet been released in the current distribution
# Filter repos without a version or a release repository
keys = prev_distro_file.repositories.keys()
prev_repo_names = set(
repo for repo in keys if _is_released(repo, prev_distro_file))
repo_names = prev_repo_names
ignored_inputs = []
else:
prev_repo_names = set(
repo for repo in repo_names if _is_released(repo, prev_distro_file))
ignored_inputs = list(set(repo_names).difference(prev_repo_names))
if len(ignored_inputs) > 0:
print(
'Ignoring inputs for which repository info not found in previous distribution '
'(did you list a package instead of a repository?):')
print('\n'.join(
sorted('\t{0}'.format(repo) for repo in ignored_inputs)))
keys = distro_file.repositories.keys()
current_repo_names = set(
repo for repo in keys if _is_released(repo, distro_file))
# Get a list of currently released packages
current_package_names = set(
pkg for repo in current_repo_names
for pkg in distro_file.repositories[repo].release_repository.package_names)
released_repos = prev_repo_names.intersection(
current_repo_names)
unreleased_repos = list(prev_repo_names.difference(
current_repo_names))
if len(unreleased_repos) == 0:
print('All inputs already released in {0}.'.format(
rosdistro_name))
repos_info = defaultdict(dict)
unprocessed_repos = prev_repo_names
while unprocessed_repos:
print('Processing repos:\n%s' %
'\n'.join(['- %s' % r for r in sorted(unprocessed_repos)]))
new_repos_to_process = set() # set containing repos that come up while processing others
for repo_name in unprocessed_repos:
repos_info[repo_name]['released'] = repo_name in released_repos
if repo_name in released_repos:
repo = distro_file.repositories[repo_name]
version = repo.release_repository.version
repos_info[repo_name]['version'] = version
else:
# Gather info on which required repos have not been released yet
# Assume dependencies will be the same as in the previous distribution and find
# which ones have been released
repo = prev_distro_file.repositories[repo_name]
release_repo = repo.release_repository
package_dependencies = set()
packages = release_repo.package_names
# Accumulate all dependencies for those packages
for package in packages:
try:
package_dependencies |= dependency_walker.get_recursive_depends(
package, ['build', 'buildtool', 'run', 'test'], ros_packages_only=True,
limit_depth=1)
except AssertionError as e:
print(e, file=sys.stderr)
# For all package dependencies, check if they are released yet
unreleased_pkgs = package_dependencies.difference(
current_package_names)
# Remove the packages which this repo provides
unreleased_pkgs = unreleased_pkgs.difference(packages)
# Get maintainer info and repo of unreleased packages
maintainers = {}
repos_blocked_by = set()
for pkg_name in unreleased_pkgs:
unreleased_repo_name = \
prev_distro_file.release_packages[pkg_name].repository_name
repos_blocked_by.add(unreleased_repo_name)
pkg_xml = prev_distribution.get_release_package_xml(pkg_name)
if pkg_xml is not None:
try:
pkg = parse_package_string(pkg_xml)
except InvalidPackage:
pass
else:
pkg_maintainers = {m.name: m.email for m in pkg.maintainers}
if unreleased_repo_name not in maintainers:
maintainers[unreleased_repo_name] = {}
maintainers[unreleased_repo_name].update(pkg_maintainers)
if maintainers:
repos_info[repo_name]['maintainers'] = maintainers
repos_info[repo_name]['repos_blocked_by'] = {}
for blocking_repo_name in repos_blocked_by:
# Get url of blocking repos
repo_url = None
blocking_repo = prev_distro_file.repositories[blocking_repo_name]
if blocking_repo.source_repository:
repo_url = blocking_repo.source_repository.url
elif blocking_repo.doc_repository:
repo_url = blocking_repo.doc_repository.url
repos_info[repo_name]['repos_blocked_by'].update(
{blocking_repo_name: repo_url})
# Mark blocking relationship in other direction
if blocking_repo_name not in repos_info:
new_repos_to_process.add(blocking_repo_name)
repos_info[blocking_repo_name] = {}
if 'repos_blocking' not in repos_info[blocking_repo_name]:
repos_info[blocking_repo_name]['repos_blocking'] = set([])
repos_info[blocking_repo_name]['repos_blocking'].add(repo_name)
# Get url of repo
repo_url = None
if repo.source_repository:
repo_url = repo.source_repository.url
elif repo.doc_repository:
repo_url = repo.doc_repository.url
if repo_url:
repos_info[repo_name]['url'] = repo_url
new_repos_to_process.discard(repo_name) # this repo has been fully processed now
for repo_name in repos_info.keys():
# Recursively get all repos being blocked by this repo
recursive_blocks = set([])
repos_to_check = set([repo_name])
while repos_to_check:
next_repo_to_check = repos_to_check.pop()
blocks = repos_info[next_repo_to_check].get('repos_blocking', set([]))
new_blocks = blocks - recursive_blocks
repos_to_check |= new_blocks
recursive_blocks |= new_blocks
if recursive_blocks:
repos_info[repo_name]['recursive_repos_blocking'] = recursive_blocks
unprocessed_repos = new_repos_to_process
return repos_info
def _get_blocked_releases_info(config_url, rosdistro_name, repo_names=None):
import rosdistro
from rosdistro.dependency_walker import DependencyWalker
from catkin_pkg.package import InvalidPackage, parse_package_string
prev_rosdistro_name = None
config = get_config_index(config_url)
index = rosdistro.get_index(config.rosdistro_index_url)
valid_rosdistro_names = list(index.distributions.keys())
valid_rosdistro_names.sort()
if rosdistro_name is None:
rosdistro_name = valid_rosdistro_names[-1]
print('Checking packages for "%s" distribution' % rosdistro_name)
# Find the previous distribution to the current one
try:
i = valid_rosdistro_names.index(rosdistro_name)
except ValueError:
print('Distribution key not found in list of valid distributions.',
file=sys.stderr)
exit(-1)
if i == 0:
print('No previous distribution found.', file=sys.stderr)
exit(-1)
prev_rosdistro_name = valid_rosdistro_names[i - 1]
cache = rosdistro.get_distribution_cache(index, rosdistro_name)
distro_file = cache.distribution_file
prev_cache = rosdistro.get_distribution_cache(index, prev_rosdistro_name)
prev_distribution = rosdistro.get_cached_distribution(index,
prev_rosdistro_name,
cache=prev_cache)
prev_distro_file = prev_cache.distribution_file
dependency_walker = DependencyWalker(prev_distribution)
if repo_names is None:
# Check missing dependencies for packages that were in the previous
# distribution that have not yet been released in the current distribution
# Filter repos without a version or a release repository
keys = prev_distro_file.repositories.keys()
prev_repo_names = set(repo for repo in keys
if _is_released(repo, prev_distro_file))
repo_names = prev_repo_names
ignored_inputs = []
else:
prev_repo_names = set(repo for repo in repo_names
if _is_released(repo, prev_distro_file))
ignored_inputs = list(set(repo_names).difference(prev_repo_names))
if len(ignored_inputs) > 0:
print(
'Ignoring inputs for which repository info not found in previous distribution '
'(did you list a package instead of a repository?):')
print('\n'.join(
sorted('\t{0}'.format(repo) for repo in ignored_inputs)))
keys = distro_file.repositories.keys()
current_repo_names = set(repo for repo in keys
if _is_released(repo, distro_file))
# Get a list of currently released packages
current_package_names = set(
pkg for repo in current_repo_names for pkg in
distro_file.repositories[repo].release_repository.package_names)
released_repos = prev_repo_names.intersection(current_repo_names)
unreleased_repos = list(prev_repo_names.difference(current_repo_names))
if len(unreleased_repos) == 0:
print('All inputs already released in {0}.'.format(rosdistro_name))
repos_info = defaultdict(dict)
unprocessed_repos = prev_repo_names
while unprocessed_repos:
print('Processing repos:\n%s' %
'\n'.join(['- %s' % r for r in sorted(unprocessed_repos)]))
new_repos_to_process = set(
) # set containing repos that come up while processing others
for repo_name in unprocessed_repos:
repos_info[repo_name]['released'] = repo_name in released_repos
if repo_name in released_repos:
repo = distro_file.repositories[repo_name]
version = repo.release_repository.version
repos_info[repo_name]['version'] = version
else:
# Gather info on which required repos have not been released yet
# Assume dependencies will be the same as in the previous distribution and find
# which ones have been released
repo = prev_distro_file.repositories[repo_name]
release_repo = repo.release_repository
package_dependencies = set()
packages = release_repo.package_names
# Accumulate all dependencies for those packages
for package in packages:
try:
package_dependencies |= dependency_walker.get_recursive_depends(
package, ['build', 'buildtool', 'run', 'test'],
ros_packages_only=True,
limit_depth=1)
except AssertionError as e:
print(e, file=sys.stderr)
# For all package dependencies, check if they are released yet
unreleased_pkgs = package_dependencies.difference(
current_package_names)
# Remove the packages which this repo provides
unreleased_pkgs = unreleased_pkgs.difference(packages)
# Get maintainer info and repo of unreleased packages
maintainers = {}
repos_blocked_by = set()
for pkg_name in unreleased_pkgs:
unreleased_repo_name = \
prev_distro_file.release_packages[pkg_name].repository_name
repos_blocked_by.add(unreleased_repo_name)
pkg_xml = prev_distribution.get_release_package_xml(
pkg_name)
if pkg_xml is not None:
try:
pkg = parse_package_string(pkg_xml)
except InvalidPackage:
pass
else:
pkg_maintainers = {
m.name: m.email
for m in pkg.maintainers
}
if unreleased_repo_name not in maintainers:
maintainers[unreleased_repo_name] = {}
maintainers[unreleased_repo_name].update(
pkg_maintainers)
if maintainers:
repos_info[repo_name]['maintainers'] = maintainers
repos_info[repo_name]['repos_blocked_by'] = {}
for blocking_repo_name in repos_blocked_by:
# Get url of blocking repos
repo_url = None
blocking_repo = prev_distro_file.repositories[
blocking_repo_name]
if blocking_repo.source_repository:
repo_url = blocking_repo.source_repository.url
elif blocking_repo.doc_repository:
repo_url = blocking_repo.doc_repository.url
repos_info[repo_name]['repos_blocked_by'].update(
{blocking_repo_name: repo_url})
# Mark blocking relationship in other direction
if blocking_repo_name not in repos_info:
new_repos_to_process.add(blocking_repo_name)
repos_info[blocking_repo_name] = {}
if 'repos_blocking' not in repos_info[blocking_repo_name]:
repos_info[blocking_repo_name]['repos_blocking'] = set(
[])
repos_info[blocking_repo_name]['repos_blocking'].add(
repo_name)
# Get url of repo
repo_url = None
if repo.source_repository:
repo_url = repo.source_repository.url
elif repo.doc_repository:
repo_url = repo.doc_repository.url
if repo_url:
repos_info[repo_name]['url'] = repo_url
new_repos_to_process.discard(
repo_name) # this repo has been fully processed now
for repo_name in repos_info.keys():
# Recursively get all repos being blocked by this repo
recursive_blocks = set([])
repos_to_check = set([repo_name])
while repos_to_check:
next_repo_to_check = repos_to_check.pop()
blocks = repos_info[next_repo_to_check].get(
'repos_blocking', set([]))
new_blocks = blocks - recursive_blocks
repos_to_check |= new_blocks
recursive_blocks |= new_blocks
if recursive_blocks:
repos_info[repo_name][
'recursive_repos_blocking'] = recursive_blocks
unprocessed_repos = new_repos_to_process
return repos_info
def get_blocking_info(distro_key, repo_names, depth):
prev_distro_key = None
index = rosdistro.get_index(rosdistro.get_index_url())
valid_distro_keys = index.distributions.keys()
valid_distro_keys.sort()
if distro_key is None:
distro_key = valid_distro_keys[-1]
print('Checking packages for "%s" distribution' % distro_key)
# Find the previous distribution to the current one
try:
i = valid_distro_keys.index(distro_key)
except ValueError:
print('Distribution key not found in list of valid distributions.')
exit(-1)
if i == 0:
print('No previous distribution found.')
exit(-1)
prev_distro_key = valid_distro_keys[i - 1]
cache = rosdistro.get_distribution_cache(index, distro_key)
distro_file = cache.distribution_file
prev_cache = rosdistro.get_distribution_cache(index, prev_distro_key)
prev_distribution = rosdistro.get_cached_distribution(
index, prev_distro_key, cache=prev_cache)
prev_distro_file = prev_cache.distribution_file
dependency_walker = DependencyWalker(prev_distribution)
if repo_names is None:
# Check missing dependencies for packages that were in the previous
# distribution that have not yet been released in the current distribution
# Filter repos without a version or a release repository
keys = prev_distro_file.repositories.keys()
prev_repo_names = set(
repo for repo in keys if is_released(repo, prev_distro_file))
repo_names = prev_repo_names
ignored_inputs = []
else:
prev_repo_names = set(
repo for repo in repo_names if is_released(repo, prev_distro_file))
ignored_inputs = list(set(repo_names).difference(prev_repo_names))
if len(ignored_inputs) > 0:
print('Ignoring inputs for which repository info not found in previous distribution' +
' (did you list a package instead of a repository?):')
print('\n'.join(
sorted('\t{0}'.format(repo) for repo in ignored_inputs)))
keys = distro_file.repositories.keys()
current_repo_names = set(
repo for repo in keys if is_released(repo, distro_file))
released_repos = prev_repo_names.intersection(
current_repo_names)
unreleased_repos = list(prev_repo_names.difference(
current_repo_names))
# Get a list of currently released packages
current_package_names = set(
pkg for repo in current_repo_names
for pkg in distro_file.repositories[repo].release_repository.package_names)
# Construct a dictionary where keys are repository names and values are a list
# of the repos blocking/blocked by that repo
blocked_repos = {}
blocking_repos = {}
unblocked_blocking_repos = set()
if len(unreleased_repos) == 0:
print('All inputs already released in {0}.'.format(
distro_key))
# Process repo dependencies
unblocked_repos = set()
total_blocking_repos = set()
for repository_name in unreleased_repos:
repo = prev_distro_file.repositories[repository_name]
release_repo = repo.release_repository
package_dependencies = set()
packages = release_repo.package_names
# Accumulate all dependencies for those packages
for package in packages:
recursive_dependencies = dependency_walker.get_recursive_depends(
package, ['build', 'run', 'buildtool'], ros_packages_only=True,
limit_depth=depth)
package_dependencies = package_dependencies.union(
recursive_dependencies)
# For all package dependencies, check if they are released yet
unreleased_pkgs = package_dependencies.difference(
current_package_names)
# remove the packages which this repo provides.
unreleased_pkgs = unreleased_pkgs.difference(packages)
# Now get the repositories for these packages.
blocking_repos_for_this_repo = set(prev_distro_file.release_packages[pkg].repository_name
for pkg in unreleased_pkgs)
if len(blocking_repos_for_this_repo) == 0:
unblocked_repos.add(repository_name)
else:
# Get the repository for the unreleased packages
blocked_repos[repository_name] = blocking_repos_for_this_repo
total_blocking_repos |= blocking_repos_for_this_repo
for blocking_repo in blocking_repos_for_this_repo:
try:
blocking_repos[blocking_repo] |= set([repository_name])
except KeyError:
blocking_repos[blocking_repo] = set([repository_name])
unblocked_blocking_repos_names = total_blocking_repos.intersection(unblocked_repos)
unblocked_blocking_repos = {
repo:blocking for repo, blocking in blocking_repos.iteritems()
if repo in unblocked_blocking_repos_names
}
unblocked_leaf_repos = unblocked_repos.difference(unblocked_blocking_repos_names)
# Double-check repositories that we think are leaf repos
for repo in unblocked_leaf_repos:
# Check only one level of depends_on
depends_on = dependency_walker.get_depends_on(package, 'build') | \
dependency_walker.get_depends_on(package, 'run') | \
dependency_walker.get_depends_on(package, 'buildtool')
if len(depends_on) != 0:
# There are packages that depend on this "leaf", but we didn't find
# them initially because they weren't related to our inputs
for package in depends_on:
depends_on_repo = prev_distro_file.release_packages[package].repository_name
try:
unblocked_blocking_repos[repo] |= set([depends_on_repo])
except KeyError:
unblocked_blocking_repos[repo] = set([depends_on_repo])
unblocked_unblocking_repos = unblocked_leaf_repos.difference(
unblocked_blocking_repos.keys())
if not len(repo_names) == (len(ignored_inputs) + len(released_repos) + len(blocked_repos.keys()) +
len(unblocked_blocking_repos.keys()) + len(unblocked_unblocking_repos)):
raise Exception('Somewhere a repo has not been accounted for')
return released_repos, blocked_repos, unblocked_blocking_repos, unblocked_unblocking_repos
# Construct a dictionary where keys are repository names and values are a list
# of the missing dependencies for that repository
blocked_repos = {}
unblocked_repos = set()
total_blocking_repos = set()
for repository_name in repo_names:
repo = prev_distro_file.repositories[repository_name]
release_repo = repo.release_repository
package_dependencies = set()
packages = release_repo.package_names
# Accumulate all dependencies for those packages
for package in packages:
recursive_dependencies = dependency_walker.get_recursive_depends(
package, ['build', 'run', 'buildtool'],
ros_packages_only=True,
limit_depth=args.depth)
package_dependencies = package_dependencies.union(
recursive_dependencies)
# For all package dependencies, check if they are released yet
unreleased_pkgs = package_dependencies.difference(current_package_names)
# remove the packages which this repo provides.
unreleased_pkgs = unreleased_pkgs.difference(packages)
# Now get the repositories for these packages.
blocking_repos = set(prev_distro_file.release_packages[pkg].repository_name
for pkg in unreleased_pkgs)
if len(blocking_repos) == 0:
unblocked_repos.add(repository_name)
else:
# Get the repository for the unreleased packages
class Distro(object):
def __init__(self, distro_name, python_version=None):
index = get_index(get_index_url())
self._distro = get_cached_distribution(index, distro_name)
self.distro_name = distro_name
# set up ROS environments
if python_version is None:
python_version = index.distributions[distro_name]["python_version"]
os.environ["ROS_PYTHON_VERSION"] = "{0}".format(python_version)
os.environ["ROS_DISTRO"] = "{0}".format(distro_name)
if "ROS_ROOT" in os.environ:
os.environ.pop("ROS_ROOT")
if "ROS_PACKAGE_PATH" in os.environ:
os.environ.pop("ROS_PACKAGE_PATH")
self._walker = DependencyWalker(self._distro,
evaluate_condition_context=os.environ)
# cache distribution type
self._distribution_type = index.distributions[distro_name][
"distribution_type"]
self._python_version = index.distributions[distro_name][
"python_version"]
self.build_packages = set()
os.environ["ROS_VERSION"] = "1" if self.check_ros1() else "2"
@property
def name(self):
return self.distro_name
def add_packages(self, packages):
self.build_packages = set(packages)
def get_depends(self, pkg):
dependencies = set()
dependencies |= self._walker.get_recursive_depends(
pkg,
[
"buildtool",
"buildtool_export",
"build",
"build_export",
"run",
"test",
"exec",
],
ros_packages_only=True,
)
return dependencies
def get_released_repo(self, pkg_name):
pkg = self._distro.release_packages[pkg_name]
repo = self._distro.repositories[
pkg.repository_name].release_repository
release_tag = get_release_tag(repo, pkg_name)
return repo.url, release_tag
def check_package(self, pkg_name):
if pkg_name in self._distro.release_packages:
return True
elif pkg_name in self.build_packages:
return True
else:
return False
def get_version(self, pkg_name):
pkg = self._distro.release_packages[pkg_name]
repo = self._distro.repositories[
pkg.repository_name].release_repository
return repo.version.split("-")[0]
def get_release_package_xml(self, pkg_name):
return self._distro.get_release_package_xml(pkg_name)
def check_ros1(self):
return self._distribution_type == "ros1"
def get_python_version(self):
return self._python_version
