def test_from_package_string(self):
        rule = PackageRule.from_string("mkl-11.0.0", self.pool)
        self.assertEqual(rule,
                         PackageRule.from_packages([mkl_11_0_0], self.pool))

        rule = PackageRule.from_string("mkl-10.2.0 | mkl-11.0.0", self.pool)
        self.assertEqual(
            rule, PackageRule.from_packages([mkl_10_2_0, mkl_11_0_0],
                                            self.pool))

        rule = PackageRule.from_string("-mkl-10.2.0 | mkl-11.0.0", self.pool)
        self.assertEqual(
            rule,
            PackageRule([
                PackageNot.from_package(mkl_10_2_0, self.pool),
                PackageLiteral.from_package(mkl_11_0_0, self.pool)
            ], self.pool))

        rule = PackageRule.from_string("-mkl-10.2.0 | -mkl-11.0.0", self.pool)
        self.assertEqual(
            rule,
            PackageRule([
                PackageNot.from_package(mkl_10_2_0, self.pool),
                PackageNot.from_package(mkl_11_0_0, self.pool)
            ], self.pool))
    def test_repr(self):
        rule_repr = repr(PackageRule.from_packages([mkl_11_0_0, mkl_10_1_0, mkl_10_2_0], self.pool))
        self.assertEqual(rule_repr, "(+mkl-10.1.0 | +mkl-10.2.0 | +mkl-11.0.0)")

        rule_repr = repr(PackageRule([PackageNot.from_package(mkl_10_2_0, self.pool)], self.pool) \
                | PackageRule.from_packages([mkl_11_0_0], self.pool))
        self.assertEqual(rule_repr, "(-mkl-10.2.0 | +mkl-11.0.0)")
    def test_repr(self):
        rule_repr = repr(
            PackageRule.from_packages([mkl_11_0_0, mkl_10_1_0, mkl_10_2_0],
                                      self.pool))
        self.assertEqual(rule_repr,
                         "(+mkl-10.1.0 | +mkl-10.2.0 | +mkl-11.0.0)")

        rule_repr = repr(PackageRule([PackageNot.from_package(mkl_10_2_0, self.pool)], self.pool) \
                | PackageRule.from_packages([mkl_11_0_0], self.pool))
        self.assertEqual(rule_repr, "(-mkl-10.2.0 | +mkl-11.0.0)")
Esempio n. 4
0
def create_install_rules(pool, req):
    """Creates the list of rules for the given install requirement."""
    clauses = []
    clauses_set = set()

    def _append_rule(rule):
        if not rule in clauses_set:
            clauses_set.add(rule)
            clauses.append(rule)

    def _extend_rules(rules):
        for rule in rules:
            _append_rule(rule)

    def _add_dependency_rules(req):
        provided = pool.what_provides(req, 'include_indirect')
        if len(provided) < 1:
            raise MissingRequirementInPool(req)
        else:
            obsolete_provided = pool.what_provides(req, 'any')
            _extend_rules(iter_conflict_rules(pool, obsolete_provided))

            for candidate in provided:
                for dependency_req in candidate.dependencies:
                    _append_rule(
                        create_depends_rule(pool, candidate, dependency_req))
                    _extend_rules(_add_dependency_rules(dependency_req))
            return clauses

    provided = pool.what_provides(req)
    rule = PackageRule.from_packages(provided, pool)
    _append_rule(rule)
    return _add_dependency_rules(req)
Esempio n. 5
0
def create_install_rules(pool, req):
    """Creates the list of rules for the given install requirement."""
    clauses = []
    clauses_set = set()

    def _append_rule(rule):
        if not rule in clauses_set:
            clauses_set.add(rule)
            clauses.append(rule)

    def _extend_rules(rules):
        for rule in rules:
            _append_rule(rule)

    def _add_dependency_rules(req):
        provided = pool.what_provides(req, 'include_indirect')
        if len(provided) < 1:
            raise MissingRequirementInPool(req)
        else:
            obsolete_provided = pool.what_provides(req, 'any')
            _extend_rules(iter_conflict_rules(pool, obsolete_provided))

            for candidate in provided:
                for dependency_req in candidate.dependencies:
                    _append_rule(create_depends_rule(pool, candidate, dependency_req))
                    _extend_rules(_add_dependency_rules(dependency_req))
            return clauses

    provided = pool.what_provides(req)
    rule = PackageRule.from_packages(provided, pool)
    _append_rule(rule)
    return _add_dependency_rules(req)
    def test_from_package_string(self):
        rule = PackageRule.from_string("mkl-11.0.0", self.pool)
        self.assertEqual(rule, PackageRule.from_packages([mkl_11_0_0], self.pool))

        rule = PackageRule.from_string("mkl-10.2.0 | mkl-11.0.0", self.pool)
        self.assertEqual(rule, PackageRule.from_packages([mkl_10_2_0, mkl_11_0_0], self.pool))

        rule = PackageRule.from_string("-mkl-10.2.0 | mkl-11.0.0", self.pool)
        self.assertEqual(rule,
                PackageRule([PackageNot.from_package(mkl_10_2_0, self.pool),
                             PackageLiteral.from_package(mkl_11_0_0, self.pool)], self.pool))

        rule = PackageRule.from_string("-mkl-10.2.0 | -mkl-11.0.0", self.pool)
        self.assertEqual(rule,
                PackageRule([PackageNot.from_package(mkl_10_2_0, self.pool),
                             PackageNot.from_package(mkl_11_0_0, self.pool)],
                            self.pool))
Esempio n. 7
0
    def test_from_package_string(self):
        r_rule = PackageRule.from_packages(self.pool, [self.mkl_11_0_0], None)

        rule = PackageRule.from_string(self.pool, "mkl-11.0.0", None)
        self.assertTrue(rule.is_equivalent(r_rule))

        r_rule = PackageRule.from_packages(self.pool, [self.mkl_10_2_0, self.mkl_11_0_0], None)
        rule = PackageRule.from_string(self.pool, "mkl-10.2.0 | mkl-11.0.0", None)
        self.assertTrue(rule.is_equivalent(r_rule))

        r_rule = PackageRule(self.pool, [-self.mkl_10_2_0.id, self.mkl_11_0_0.id], None)
        rule = PackageRule.from_string(self.pool, "-mkl-10.2.0 | mkl-11.0.0", None)
        self.assertTrue(rule.is_equivalent(r_rule))

        r_rule = PackageRule(self.pool, [-self.mkl_10_2_0.id, -self.mkl_11_0_0.id], None)
        rule = PackageRule.from_string(self.pool, "-mkl-10.2.0 | -mkl-11.0.0", None)
        self.assertTrue(rule.is_equivalent(r_rule))
Esempio n. 8
0
    def test_str(self):
        rule = PackageRule.from_packages(self.pool, [self.mkl_11_0_0,
                                         self.mkl_10_1_0, self.mkl_10_2_0], None)
        rule_repr = str(rule)
        self.assertEqual(rule_repr, "(+mkl-10.1.0 | +mkl-10.2.0 | +mkl-11.0.0)")

        rule_repr = str(PackageRule(self.pool, [-self.mkl_10_2_0.id, self.mkl_11_0_0.id], None))
        self.assertEqual(rule_repr, "(-mkl-10.2.0 | +mkl-11.0.0)")
Esempio n. 9
0
    def test_str(self):
        rule = PackageRule.from_packages(
            self.pool, [self.mkl_11_0_0, self.mkl_10_1_0, self.mkl_10_2_0],
            None)
        rule_repr = str(rule)
        self.assertEqual(rule_repr,
                         "(+mkl-10.1.0 | +mkl-10.2.0 | +mkl-11.0.0)")

        rule_repr = str(
            PackageRule(self.pool, [-self.mkl_10_2_0.id, self.mkl_11_0_0.id],
                        None))
        self.assertEqual(rule_repr, "(-mkl-10.2.0 | +mkl-11.0.0)")
Esempio n. 10
0
    def test_from_package_string(self):
        r_rule = PackageRule.from_packages(self.pool, [self.mkl_11_0_0], None)

        rule = PackageRule.from_string(self.pool, "mkl-11.0.0", None)
        self.assertTrue(rule.is_equivalent(r_rule))

        r_rule = PackageRule.from_packages(self.pool,
                                           [self.mkl_10_2_0, self.mkl_11_0_0],
                                           None)
        rule = PackageRule.from_string(self.pool, "mkl-10.2.0 | mkl-11.0.0",
                                       None)
        self.assertTrue(rule.is_equivalent(r_rule))

        r_rule = PackageRule(self.pool,
                             [-self.mkl_10_2_0.id, self.mkl_11_0_0.id], None)
        rule = PackageRule.from_string(self.pool, "-mkl-10.2.0 | mkl-11.0.0",
                                       None)
        self.assertTrue(rule.is_equivalent(r_rule))

        r_rule = PackageRule(self.pool,
                             [-self.mkl_10_2_0.id, -self.mkl_11_0_0.id], None)
        rule = PackageRule.from_string(self.pool, "-mkl-10.2.0 | -mkl-11.0.0",
                                       None)
        self.assertTrue(rule.is_equivalent(r_rule))
Esempio n. 11
0
    def test_from_packages_simple(self):
        mkl = P("mkl-10.1.0")
        numpy = P("numpy-1.7.0; depends (MKL >= 10.1.0)")
        scipy = P("scipy-0.12.0; depends (numpy >= 1.7.0)")
        remote_repository = [mkl, numpy, scipy]

        i_mkl = P("mkl-10.1.0")
        installed_repository = [i_mkl]

        pool = Pool([Repository(remote_repository), Repository(installed_repository)])

        rule = PackageRule.from_packages(pool, [mkl, i_mkl], "job_install", "numpy")

        self.assertEqual(rule.enabled, True)
        self.assertEqual(rule.literals, [mkl.id, i_mkl.id])
        self.assertEqual(rule.reason, "job_install")
    def test_or(self):
        rule = PackageRule.from_packages([mkl_10_1_0, mkl_10_2_0], self.pool)
        rule |= PackageNot.from_package(mkl_11_0_0, self.pool)

        self.assertTrue(rule.literals,
                        set([mkl_11_0_0.id, mkl_10_1_0.id, mkl_10_2_0.id]))
    def test_or(self):
        rule = PackageRule.from_packages([mkl_10_1_0, mkl_10_2_0], self.pool)
        rule |= PackageNot.from_package(mkl_11_0_0, self.pool)

        self.assertTrue(rule.literals, set([mkl_11_0_0.id, mkl_10_1_0.id, mkl_10_2_0.id]))