def main():
options = parse_arguments()
logger = StderrLogger()
if options.logfile:
logger = FileLogger(options.logfile)
if options.fields == 'all':
options.fields = sorted(Package().__dict__.keys())
else:
options.fields = options.fields.split(',')
# Set up filters
filters = []
if options.maintainer:
filters.append(MaintainerFilter(options.maintainer))
if options.category:
filters.append(CategoryFilter(options.maintainer))
if options.more_repos is not None or options.less_repos is not None:
filters.append(FamilyCountFilter(more=options.more_repos, less=options.less_repos))
if options.in_repository:
filters.append(InRepoFilter(options.in_repository))
if options.not_in_repository:
filters.append(NotInRepoFilter(options.not_in_repository))
if options.outdated_in_repository:
filters.append(OutdatedInRepoFilter(options.not_in_repository))
if not options.no_shadow:
filters.append(ShadowFilter())
repomgr = RepositoryManager(options.repos_dir)
repoproc = RepositoryProcessor(repomgr, options.statedir)
logger.Log('dumping...')
for packageset in repoproc.StreamDeserializeMulti(reponames=options.reponames):
FillPackagesetVersions(packageset)
if not PackagesetCheckFilters(packageset, *filters):
continue
if options.dump == 'packages':
for package in packageset:
print(
options.field_separator.join(
(
format_package_field(field, getattr(package, field)) for field in options.fields
)
)
)
if options.dump == 'summaries':
print(packageset[0].effname)
best_pkg_by_repo = PackagesetToBestByRepo(packageset)
for reponame in repomgr.GetNames(options.reponames):
if reponame in best_pkg_by_repo:
print(' {}: {} ({})'.format(
reponame,
best_pkg_by_repo[reponame].version,
VersionClass.ToString(best_pkg_by_repo[reponame].versionclass)
))
return 0
def Main():
options = ParseArguments()
repomgr = RepositoryManager(options.repos_dir)
repoproc = RepositoryProcessor(repomgr,
options.statedir,
safety_checks=not options.no_safety_checks)
if options.list:
print('\n'.join(repomgr.GetNames(reponames=options.reponames)))
return 0
transformer = PackageTransformer(repomgr, options.rules_dir)
logger = StderrLogger()
if options.logfile:
logger = FileLogger(options.logfile)
repositories_updated = []
repositories_not_updated = []
start = timer()
if options.fetch or options.parse or options.reprocess:
repositories_updated, repositories_not_updated = ProcessRepositories(
options=options,
logger=logger,
repoproc=repoproc,
transformer=transformer,
reponames=repomgr.GetNames(reponames=options.reponames))
if options.initdb or options.database or options.postupdate:
ProcessDatabase(
options=options,
logger=logger,
repomgr=repomgr,
repoproc=repoproc,
repositories_updated=repositories_updated,
reponames=repomgr.GetNames(reponames=options.reponames))
if (options.parse or options.reprocess) and (options.show_unmatched_rules):
ShowUnmatchedRules(options=options,
logger=logger,
transformer=transformer,
reliable=repositories_not_updated == [])
logger.Log('total time taken: {:.2f} seconds'.format((timer() - start)))
return 1 if repositories_not_updated else 0
def main() -> int:
options = parse_arguments()
logger: Logger = StderrLogger()
if options.logfile:
logger = FileLogger(options.logfile)
if options.fields == 'all':
options.fields = sorted(Package().__dict__.keys())
else:
options.fields = options.fields.split(',')
repomgr = RepositoryManager(options.repos_dir)
repoproc = RepositoryProcessor(repomgr, options.statedir,
options.parseddir)
logger.log('dumping...')
for packageset in repoproc.iter_parsed(reponames=options.reponames):
FillPackagesetVersions(packageset)
if not options.all and packageset_is_shadow_only(packageset):
continue
for package in packageset:
print(
options.field_separator.join(
(format_package_field(field, getattr(package, field))
for field in options.fields)))
return 0
def main():
options = parse_arguments()
logger = StderrLogger()
if options.logfile:
logger = FileLogger(options.logfile)
if options.fields == 'all':
options.fields = sorted(Package().__dict__.keys())
else:
options.fields = options.fields.split(',')
repomgr = RepositoryManager(options.repos_dir)
repoproc = RepositoryProcessor(repomgr, options.statedir,
options.parseddir)
logger.Log('dumping...')
for packageset in repoproc.iter_parsed(reponames=options.reponames):
FillPackagesetVersions(packageset)
if not options.all and packageset_is_shadow_only(packageset):
continue
if options.dump == 'packages':
for package in packageset:
print(
options.field_separator.join(
(format_package_field(field, getattr(package, field))
for field in options.fields)))
if options.dump == 'summaries':
print(packageset[0].effname)
best_pkg_by_repo = PackagesetToBestByRepo(packageset)
for reponame in repomgr.GetNames(options.reponames):
if reponame in best_pkg_by_repo:
print(' {}: {} ({})'.format(
reponame, best_pkg_by_repo[reponame].version,
VersionClass.ToString(
best_pkg_by_repo[reponame].versionclass)))
return 0
def test_parsers_regress(regtest):
repomgr = RepositoryManager(YamlConfig.from_path(config['REPOS_DIR']))
repoproc = RepositoryProcessor(repomgr,
'testdata',
'testdata',
safety_checks=False)
# NOTE: run the following command to canonize this test after parser or testdata update
#
# pytest -k test_parsers_regress --regtest-reset
#
with regtest:
map(
print,
sorted(
json.dumps(package.__dict__, indent=1)
for package in repoproc.iter_parse(
reponames=['have_testdata'])))
def main() -> int:
options = parse_arguments()
logger: Logger = StderrLogger()
if options.logfile:
logger = FileLogger(options.logfile)
if options.fields == 'all':
options.fields = ['effname', 'repo', 'version'] + [
slot for slot in Package.__slots__
if slot not in ['effname', 'repo', 'version']
]
else:
options.fields = options.fields.split(',')
repomgr = RepositoryManager(options.repos_dir)
repoproc = RepositoryProcessor(repomgr, options.statedir,
options.parseddir)
logger.log('dumping...')
for packageset in repoproc.iter_parsed(reponames=options.reponames,
logger=logger):
if options.from_ is not None and packageset[0].effname < options.from_:
continue
if options.to is not None and packageset[0].effname > options.to:
break
fill_packageset_versions(packageset)
if not options.all and packageset_is_shadow_only(packageset):
continue
for package in packageset:
print(
options.field_separator.join(
(format_package_field(field, getattr(package, field, None))
for field in options.fields)))
return 0
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with repology. If not, see <http://www.gnu.org/licenses/>.
import unittest
from typing import Any, Dict
from repology.config import config
from repology.repomgr import RepositoryManager
from repology.repoproc import RepositoryProcessor
repomgr = RepositoryManager(config['REPOS_DIR'])
repoproc = RepositoryProcessor(repomgr, 'testdata', 'testdata', safety_checks=False)
class TestParsers(unittest.TestCase):
def setUp(self) -> None:
self.maxDiff = None
self.packages = list(repoproc.iter_parse(reponames=['have_testdata']))
def check_package(self, name: str, reference: Dict[str, Any]) -> None:
reference_with_default = {
# repo must be filled
# family must be filled
'subrepo': None,
# name must be filled
def get_repo_manager(self) -> RepositoryManager:
return RepositoryManager(self.options.repos_dir)
# along with repology. If not, see <http://www.gnu.org/licenses/>.
# mypy: no-disallow-untyped-calls
import unittest
from typing import Any, Dict
from repology.package import Package, PackageFlags
from repology.repomgr import RepositoryManager
from repology.transformer import PackageTransformer
repomgr = RepositoryManager(repostext="""
[
{ name: foo, desc: foo, family: foo, sources: [] },
{ name: bar, desc: bar, family: bar, sources: [] },
{ name: baz, desc: baz, family: baz, sources: [] }
]
""")
class TestPackageTransformer(unittest.TestCase):
def check_transformer(self, rulestext: str, *packages: Dict[str, Any]) -> None:
transformer = PackageTransformer(repomgr, rulestext=rulestext)
for packagedict in packages:
create_params = {}
expected_params = {}
for field, value in packagedict.items():
if field.startswith('expect_'):
expected_params[field[7:]] = value
else:
def get_repo_manager(self) -> RepositoryManager:
return RepositoryManager(self.get_repos_config())
# along with repology. If not, see <http://www.gnu.org/licenses/>.
from collections import defaultdict
from repology.repomgr import RepositoryManager
from repology.transformer import PackageTransformer
from repology.transformer.ruleset import Ruleset
from repology.yamlloader import YamlConfig
from ..package import PackageSample
_repomgr = RepositoryManager(YamlConfig.from_text("""
[
{ name: dummyrepo, desc: dummyrepo, family: dummyrepo, sources: [] },
{ name: foo, desc: foo, family: foo, sources: [] },
{ name: bar, desc: bar, family: bar, sources: [] },
{ name: baz, desc: baz, family: baz, sources: [] }
]
"""))
def check_transformer(rulestext: str, *samples: PackageSample) -> None:
__tracebackhide__ = True
ruleset = Ruleset(YamlConfig.from_text(rulestext))
sample_by_repo = defaultdict(list)
for sample in samples:
sample_by_repo[sample.package.repo].append(sample)