Example #1
0
    def test_parse_simple(self):

        a = Context.__keytransform__(UnitsContainer({"[time]": -1}), UnitsContainer({"[length]": 1}))
        b = Context.__keytransform__(UnitsContainer({"[length]": 1}), UnitsContainer({"[time]": -1}))

        s = ["@context longcontextname", "[length] -> 1 / [time]: c / value", "1 / [time] -> [length]: c / value"]

        c = Context.from_lines(s)
        self.assertEqual(c.name, "longcontextname")
        self.assertEqual(c.aliases, ())
        self.assertEqual(c.defaults, {})
        self.assertEqual(set(c.funcs.keys()), set((a, b)))
        self._test_ctx(c)

        s = ["@context longcontextname = lc", "[length] <-> 1 / [time]: c / value"]

        c = Context.from_lines(s)
        self.assertEqual(c.name, "longcontextname")
        self.assertEqual(c.aliases, ("lc",))
        self.assertEqual(c.defaults, {})
        self.assertEqual(set(c.funcs.keys()), set((a, b)))
        self._test_ctx(c)

        s = ["@context longcontextname = lc = lcn", "[length] <-> 1 / [time]: c / value"]

        c = Context.from_lines(s)
        self.assertEqual(c.name, "longcontextname")
        self.assertEqual(c.aliases, ("lc", "lcn"))
        self.assertEqual(c.defaults, {})
        self.assertEqual(set(c.funcs.keys()), set((a, b)))
        self._test_ctx(c)
Example #2
0
    def test_parse_parameterized(self):
        a = Context.__keytransform__(UnitsContainer({"[time]": -1.0}),
                                     UnitsContainer({"[length]": 1.0}))
        b = Context.__keytransform__(UnitsContainer({"[length]": 1.0}),
                                     UnitsContainer({"[time]": -1.0}))

        s = [
            "@context(n=1) longcontextname",
            "[length] <-> 1 / [time]: n * c / value"
        ]

        c = Context.from_lines(s)
        self.assertEqual(c.defaults, {"n": 1})
        self.assertEqual(c.funcs.keys(), {a, b})
        self._test_ctx(c)

        s = [
            "@context(n=1, bla=2) longcontextname",
            "[length] <-> 1 / [time]: n * c / value / bla",
        ]

        c = Context.from_lines(s)
        self.assertEqual(c.defaults, {"n": 1, "bla": 2})
        self.assertEqual(c.funcs.keys(), {a, b})

        # If the variable is not present in the definition, then raise an error
        s = [
            "@context(n=1) longcontextname",
            "[length] <-> 1 / [time]: c / value"
        ]
        self.assertRaises(DefinitionSyntaxError, Context.from_lines, s)
Example #3
0
    def test_parse_simple(self):

        a = Context.__keytransform__(UnitsContainer({'[time]': -1}), UnitsContainer({'[length]': 1}))
        b = Context.__keytransform__(UnitsContainer({'[length]': 1}), UnitsContainer({'[time]': -1}))

        s = ['@context longcontextname',
             '[length] -> 1 / [time]: c / value',
             '1 / [time] -> [length]: c / value']

        c = Context.from_lines(s)
        self.assertEqual(c.name, 'longcontextname')
        self.assertEqual(c.aliases, ())
        self.assertEqual(c.defaults, {})
        self.assertEqual(set(c.funcs.keys()), set((a, b)))
        self._test_ctx(c)

        s = ['@context longcontextname = lc',
             '[length] <-> 1 / [time]: c / value']

        c = Context.from_lines(s)
        self.assertEqual(c.name, 'longcontextname')
        self.assertEqual(c.aliases, ('lc', ))
        self.assertEqual(c.defaults, {})
        self.assertEqual(set(c.funcs.keys()), set((a, b)))
        self._test_ctx(c)

        s = ['@context longcontextname = lc = lcn',
             '[length] <-> 1 / [time]: c / value']

        c = Context.from_lines(s)
        self.assertEqual(c.name, 'longcontextname')
        self.assertEqual(c.aliases, ('lc', 'lcn', ))
        self.assertEqual(c.defaults, {})
        self.assertEqual(set(c.funcs.keys()), set((a, b)))
        self._test_ctx(c)
Example #4
0
    def test_parse_parameterized(self):
        a = Context.__keytransform__(UnitsContainer({'[time]': -1.}),
                                     UnitsContainer({'[length]': 1.}))
        b = Context.__keytransform__(UnitsContainer({'[length]': 1.}),
                                     UnitsContainer({'[time]': -1.}))

        s = [
            '@context(n=1) longcontextname',
            '[length] <-> 1 / [time]: n * c / value'
        ]

        c = Context.from_lines(s)
        self.assertEqual(c.defaults, {'n': 1})
        self.assertEqual(set(c.funcs.keys()), set((a, b)))
        self._test_ctx(c)

        s = [
            '@context(n=1, bla=2) longcontextname',
            '[length] <-> 1 / [time]: n * c / value / bla'
        ]

        c = Context.from_lines(s)
        self.assertEqual(c.defaults, {'n': 1, 'bla': 2})
        self.assertEqual(set(c.funcs.keys()), set((a, b)))

        # If the variable is not present in the definition, then raise an error
        s = [
            '@context(n=1) longcontextname',
            '[length] <-> 1 / [time]: c / value'
        ]
        self.assertRaises(ValueError, Context.from_lines, s)
    def test_parse_simple(self):

        a = Context.__keytransform__(UnitsContainer({'[time]': -1}), UnitsContainer({'[length]': 1}))
        b = Context.__keytransform__(UnitsContainer({'[length]': 1}), UnitsContainer({'[time]': -1}))

        s = ['@context longcontextname',
             '[length] -> 1 / [time]: c / value',
             '1 / [time] -> [length]: c / value']

        c = Context.from_lines(s)
        self.assertEqual(c.name, 'longcontextname')
        self.assertEqual(c.aliases, ())
        self.assertEqual(c.defaults, {})
        self.assertEqual(set(c.funcs.keys()), set((a, b)))
        self._test_ctx(c)

        s = ['@context longcontextname = lc',
             '[length] <-> 1 / [time]: c / value']

        c = Context.from_lines(s)
        self.assertEqual(c.name, 'longcontextname')
        self.assertEqual(c.aliases, ('lc', ))
        self.assertEqual(c.defaults, {})
        self.assertEqual(set(c.funcs.keys()), set((a, b)))
        self._test_ctx(c)

        s = ['@context longcontextname = lc = lcn',
             '[length] <-> 1 / [time]: c / value']

        c = Context.from_lines(s)
        self.assertEqual(c.name, 'longcontextname')
        self.assertEqual(c.aliases, ('lc', 'lcn', ))
        self.assertEqual(c.defaults, {})
        self.assertEqual(set(c.funcs.keys()), set((a, b)))
        self._test_ctx(c)
Example #6
0
    def test_parse_define(self):
        a = Context.__keytransform__(UnitsContainer({"[time]": -1}), UnitsContainer({"[length]": 1.0}))
        b = Context.__keytransform__(UnitsContainer({"[length]": 1}), UnitsContainer({"[time]": -1.0}))

        s = ["@context longcontextname", "[length] <-> 1 / [time]: c / value"]
        c = Context.from_lines(s)
        self.assertEqual(c.defaults, {})
        self.assertEqual(set(c.funcs.keys()), set((a, b)))
        self._test_ctx(c)
Example #7
0
    def test_parse_define(self):
        a = Context.__keytransform__(UnitsContainer({'[time]': -1}), UnitsContainer({'[length]': 1.}))
        b = Context.__keytransform__(UnitsContainer({'[length]': 1}), UnitsContainer({'[time]': -1.}))

        s = ['@context longcontextname',
             '[length] <-> 1 / [time]: c / value']
        c = Context.from_lines(s)
        self.assertEqual(c.defaults, {})
        self.assertEqual(set(c.funcs.keys()), set((a, b)))
        self._test_ctx(c)
Example #8
0
    def test_parse_define(self):
        a = Context.__keytransform__(UnitsContainer({"[time]": -1}),
                                     UnitsContainer({"[length]": 1.0}))
        b = Context.__keytransform__(UnitsContainer({"[length]": 1}),
                                     UnitsContainer({"[time]": -1.0}))

        s = ["@context longcontextname", "[length] <-> 1 / [time]: c / value"]
        c = Context.from_lines(s)
        self.assertEqual(c.defaults, {})
        self.assertEqual(c.funcs.keys(), {a, b})
        self._test_ctx(c)
    def test_parse_auto_inverse(self):

        a = Context.__keytransform__(UnitsContainer({'[time]': -1.}), UnitsContainer({'[length]': 1.}))
        b = Context.__keytransform__(UnitsContainer({'[length]': 1.}), UnitsContainer({'[time]': -1.}))

        s = ['@context longcontextname',
             '[length] <-> 1 / [time]: c / value']

        c = Context.from_lines(s)
        self.assertEqual(c.defaults, {})
        self.assertEqual(set(c.funcs.keys()), set((a, b)))
        self._test_ctx(c)
    def test_defined(self):
        ureg = self.ureg
        with ureg.context('sp'):
            pass

        a = Context.__keytransform__(UnitsContainer({'[time]': -1.}), UnitsContainer({'[length]': 1.}))
        b = Context.__keytransform__(UnitsContainer({'[length]': 1.}), UnitsContainer({'[time]': -1.}))
        self.assertIn(a, ureg._contexts['sp'].funcs)
        self.assertIn(b, ureg._contexts['sp'].funcs)
        with ureg.context('sp'):
            self.assertIn(a, ureg._active_ctx)
            self.assertIn(b, ureg._active_ctx)
Example #11
0
    def test_defined(self):
        ureg = self.ureg
        with ureg.context('sp'):
            pass

        a = Context.__keytransform__(UnitsContainer({'[time]': -1.}), UnitsContainer({'[length]': 1.}))
        b = Context.__keytransform__(UnitsContainer({'[length]': 1.}), UnitsContainer({'[time]': -1.}))
        self.assertIn(a, ureg._contexts['sp'].funcs)
        self.assertIn(b, ureg._contexts['sp'].funcs)
        with ureg.context('sp'):
            self.assertIn(a, ureg._active_ctx)
            self.assertIn(b, ureg._active_ctx)
Example #12
0
    def test_defined(self):
        ureg = self.ureg
        with ureg.context("sp"):
            pass

        a = Context.__keytransform__(UnitsContainer({"[time]": -1.0}), UnitsContainer({"[length]": 1.0}))
        b = Context.__keytransform__(UnitsContainer({"[length]": 1.0}), UnitsContainer({"[time]": -1.0}))
        self.assertIn(a, ureg._contexts["sp"].funcs)
        self.assertIn(b, ureg._contexts["sp"].funcs)
        with ureg.context("sp"):
            self.assertIn(a, ureg._active_ctx)
            self.assertIn(b, ureg._active_ctx)
Example #13
0
    def test_parse_auto_inverse(self):

        a = Context.__keytransform__(UnitsContainer({"[time]": -1.0}),
                                     UnitsContainer({"[length]": 1.0}))
        b = Context.__keytransform__(UnitsContainer({"[length]": 1.0}),
                                     UnitsContainer({"[time]": -1.0}))

        s = ["@context longcontextname", "[length] <-> 1 / [time]: c / value"]

        c = Context.from_lines(s)
        assert c.defaults == {}
        assert c.funcs.keys() == {a, b}
        self._test_ctx(c)
Example #14
0
    def test_defined(self):
        ureg = self.ureg
        with ureg.context("sp"):
            pass

        a = Context.__keytransform__(UnitsContainer({"[time]": -1.0}),
                                     UnitsContainer({"[length]": 1.0}))
        b = Context.__keytransform__(UnitsContainer({"[length]": 1.0}),
                                     UnitsContainer({"[time]": -1.0}))
        self.assertIn(a, ureg._contexts["sp"].funcs)
        self.assertIn(b, ureg._contexts["sp"].funcs)
        with ureg.context("sp"):
            self.assertIn(a, ureg._active_ctx)
            self.assertIn(b, ureg._active_ctx)
Example #15
0
    def test_parse_parameterized(self):
        a = Context.__keytransform__(UnitsContainer({"[time]": -1.0}), UnitsContainer({"[length]": 1.0}))
        b = Context.__keytransform__(UnitsContainer({"[length]": 1.0}), UnitsContainer({"[time]": -1.0}))

        s = ["@context(n=1) longcontextname", "[length] <-> 1 / [time]: n * c / value"]

        c = Context.from_lines(s)
        self.assertEqual(c.defaults, {"n": 1})
        self.assertEqual(set(c.funcs.keys()), set((a, b)))
        self._test_ctx(c)

        # If the variable is not present in the definition, then raise an error
        s = ["@context(n=1) longcontextname", "[length] <-> 1 / [time]: c / value"]
        self.assertRaises(ValueError, Context.from_lines, s)
Example #16
0
    def test_defined(self):
        ureg = self.ureg
        with ureg.context("sp"):
            pass

        a = Context.__keytransform__(UnitsContainer({"[time]": -1.0}),
                                     UnitsContainer({"[length]": 1.0}))
        b = Context.__keytransform__(UnitsContainer({"[length]": 1.0}),
                                     UnitsContainer({"[time]": -1.0}))
        assert a in ureg._contexts["sp"].funcs
        assert b in ureg._contexts["sp"].funcs
        with ureg.context("sp"):
            assert a in ureg._active_ctx
            assert b in ureg._active_ctx
Example #17
0
    def test_spectroscopy(self):
        ureg = self.ureg
        eq = (532.0 * ureg.nm, 563.5 * ureg.terahertz, 2.33053 * ureg.eV)
        with ureg.context("sp"):
            from pint.util import find_shortest_path

            for a, b in itertools.product(eq, eq):
                for x in range(2):
                    if x == 1:
                        a = a.to_base_units()
                        b = b.to_base_units()
                    da, db = Context.__keytransform__(a.dimensionality,
                                                      b.dimensionality)
                    p = find_shortest_path(ureg._active_ctx.graph, da, db)
                    assert p
                    msg = "{} <-> {}".format(a, b)
                    # assertAlmostEqualRelError converts second to first
                    helpers.assert_quantity_almost_equal(b,
                                                         a,
                                                         rtol=0.01,
                                                         msg=msg)

        for a, b in itertools.product(eq, eq):
            helpers.assert_quantity_almost_equal(a.to(b.units, "sp"),
                                                 b,
                                                 rtol=0.01)
Example #18
0
    def test_textile(self):
        ureg = self.ureg
        qty_direct = 1.331 * ureg.tex
        with pytest.raises(DimensionalityError):
            qty_indirect = qty_direct.to("Nm")

        with ureg.context("textile"):
            from pint.util import find_shortest_path

            qty_indirect = qty_direct.to("Nm")
            a = qty_direct.to_base_units()
            b = qty_indirect.to_base_units()
            da, db = Context.__keytransform__(a.dimensionality,
                                              b.dimensionality)
            p = find_shortest_path(ureg._active_ctx.graph, da, db)
            assert p
            msg = "{} <-> {}".format(a, b)
            helpers.assert_quantity_almost_equal(b, a, rtol=0.01, msg=msg)

            # Check RKM <-> cN/tex conversion
            helpers.assert_quantity_almost_equal(1 * ureg.RKM,
                                                 0.980665 * ureg.cN / ureg.tex)
            helpers.assert_quantity_almost_equal((1 / 0.980665) * ureg.RKM,
                                                 1 * ureg.cN / ureg.tex)
            assert (round(
                abs((1 * ureg.RKM).to(ureg.cN / ureg.tex).m - 0.980665),
                7) == 0)
            assert (round(
                abs((1 * ureg.cN / ureg.tex).to(ureg.RKM).m - 1 / 0.980665),
                7) == 0)
Example #19
0
    def test_textile(self):
        ureg = self.ureg
        qty_direct = 1.331 * ureg.tex
        with self.assertRaises(DimensionalityError):
            qty_indirect = qty_direct.to("Nm")

        with ureg.context("textile"):
            from pint.util import find_shortest_path

            qty_indirect = qty_direct.to("Nm")
            a = qty_direct.to_base_units()
            b = qty_indirect.to_base_units()
            da, db = Context.__keytransform__(a.dimensionality,
                                              b.dimensionality)
            p = find_shortest_path(ureg._active_ctx.graph, da, db)
            self.assertTrue(p)
            msg = "{} <-> {}".format(a, b)
            self.assertQuantityAlmostEqual(b, a, rtol=0.01, msg=msg)

            # Check RKM <-> cN/tex conversion
            self.assertQuantityAlmostEqual(1 * ureg.RKM,
                                           0.980665 * ureg.cN / ureg.tex)
            self.assertQuantityAlmostEqual((1 / 0.980665) * ureg.RKM,
                                           1 * ureg.cN / ureg.tex)
            self.assertAlmostEqual((1 * ureg.RKM).to(ureg.cN / ureg.tex).m,
                                   0.980665)
            self.assertAlmostEqual((1 * ureg.cN / ureg.tex).to(ureg.RKM).m,
                                   1 / 0.980665)
Example #20
0
    def test_parse_simple(self):

        a = Context.__keytransform__(UnitsContainer({"[time]": -1}),
                                     UnitsContainer({"[length]": 1}))
        b = Context.__keytransform__(UnitsContainer({"[length]": 1}),
                                     UnitsContainer({"[time]": -1}))

        s = [
            "@context longcontextname",
            "[length] -> 1 / [time]: c / value",
            "1 / [time] -> [length]: c / value",
        ]

        c = Context.from_lines(s)
        self.assertEqual(c.name, "longcontextname")
        self.assertEqual(c.aliases, ())
        self.assertEqual(c.defaults, {})
        self.assertEqual(c.funcs.keys(), {a, b})
        self._test_ctx(c)

        s = [
            "@context longcontextname = lc",
            "[length] <-> 1 / [time]: c / value"
        ]

        c = Context.from_lines(s)
        self.assertEqual(c.name, "longcontextname")
        self.assertEqual(c.aliases, ("lc", ))
        self.assertEqual(c.defaults, {})
        self.assertEqual(c.funcs.keys(), {a, b})
        self._test_ctx(c)

        s = [
            "@context longcontextname = lc = lcn",
            "[length] <-> 1 / [time]: c / value",
        ]

        c = Context.from_lines(s)
        self.assertEqual(c.name, "longcontextname")
        self.assertEqual(c.aliases, ("lc", "lcn"))
        self.assertEqual(c.defaults, {})
        self.assertEqual(c.funcs.keys(), {a, b})
        self._test_ctx(c)
Example #21
0
    def test_parse_simple(self):

        a = Context.__keytransform__(UnitsContainer({"[time]": -1}),
                                     UnitsContainer({"[length]": 1}))
        b = Context.__keytransform__(UnitsContainer({"[length]": 1}),
                                     UnitsContainer({"[time]": -1}))

        s = [
            "@context longcontextname",
            "[length] -> 1 / [time]: c / value",
            "1 / [time] -> [length]: c / value",
        ]

        c = Context.from_lines(s)
        assert c.name == "longcontextname"
        assert c.aliases == ()
        assert c.defaults == {}
        assert c.funcs.keys() == {a, b}
        self._test_ctx(c)

        s = [
            "@context longcontextname = lc",
            "[length] <-> 1 / [time]: c / value"
        ]

        c = Context.from_lines(s)
        assert c.name == "longcontextname"
        assert c.aliases == ("lc", )
        assert c.defaults == {}
        assert c.funcs.keys() == {a, b}
        self._test_ctx(c)

        s = [
            "@context longcontextname = lc = lcn",
            "[length] <-> 1 / [time]: c / value",
        ]

        c = Context.from_lines(s)
        assert c.name == "longcontextname"
        assert c.aliases == ("lc", "lcn")
        assert c.defaults == {}
        assert c.funcs.keys() == {a, b}
        self._test_ctx(c)
Example #22
0
    def test_parse_parameterized(self):
        a = Context.__keytransform__(UnitsContainer({'[time]': -1.}), UnitsContainer({'[length]': 1.}))
        b = Context.__keytransform__(UnitsContainer({'[length]': 1.}), UnitsContainer({'[time]': -1.}))

        s = ['@context(n=1) longcontextname',
             '[length] <-> 1 / [time]: n * c / value']

        c = Context.from_lines(s)
        self.assertEqual(c.defaults, {'n': 1})
        self.assertEqual(set(c.funcs.keys()), set((a, b)))
        self._test_ctx(c)

        s = ['@context(n=1, bla=2) longcontextname',
             '[length] <-> 1 / [time]: n * c / value / bla']

        c = Context.from_lines(s)
        self.assertEqual(c.defaults, {'n': 1, 'bla': 2})
        self.assertEqual(set(c.funcs.keys()), set((a, b)))

        # If the variable is not present in the definition, then raise an error
        s = ['@context(n=1) longcontextname',
             '[length] <-> 1 / [time]: c / value']
        self.assertRaises(ValueError, Context.from_lines, s)
Example #23
0
    def test_textile(self):
        ureg = self.ureg
        qty_direct = 1.331 * ureg.tex
        with self.assertRaises(errors.DimensionalityError):
            qty_indirect = qty_direct.to('Nm')

        with ureg.context('textile'):
            from pint.util import find_shortest_path
            qty_indirect = qty_direct.to('Nm')
            a = qty_direct.to_base_units()
            b = qty_indirect.to_base_units()
            da, db = Context.__keytransform__(a.dimensionality,
                                              b.dimensionality)
            p = find_shortest_path(ureg._active_ctx.graph, da, db)
            self.assertTrue(p)
            msg = '{} <-> {}'.format(a, b)
            self.assertQuantityAlmostEqual(b, a, rtol=0.01, msg=msg)
Example #24
0
    def test_spectroscopy(self):
        ureg = self.ureg
        eq = (532.0 * ureg.nm, 563.5 * ureg.terahertz, 2.33053 * ureg.eV)
        with ureg.context("sp"):
            from pint.util import find_shortest_path

            for a, b in itertools.product(eq, eq):
                for x in range(2):
                    if x == 1:
                        a = a.to_base_units()
                        b = b.to_base_units()
                    da, db = Context.__keytransform__(a.dimensionality, b.dimensionality)
                    p = find_shortest_path(ureg._active_ctx.graph, da, db)
                    self.assertTrue(p)
                    msg = "{0} <-> {1}".format(a, b)
                    # assertAlmostEqualRelError converts second to first
                    self.assertQuantityAlmostEqual(b, a, rtol=0.01, msg=msg)

        for a, b in itertools.product(eq, eq):
            self.assertQuantityAlmostEqual(a.to(b.units, "sp"), b, rtol=0.01)
Example #25
0
    def test_spectroscopy(self):
        ureg = self.ureg
        eq = (532. * ureg.nm, 563.5 * ureg.terahertz, 2.33053 * ureg.eV)
        with ureg.context('sp'):
            from pint.util import find_shortest_path
            for a, b in itertools.product(eq, eq):
                for x in range(2):
                    if x == 1:
                        a = a.to_base_units()
                        b = b.to_base_units()
                    da, db = Context.__keytransform__(a.dimensionality,
                                                      b.dimensionality)
                    p = find_shortest_path(ureg._active_ctx.graph, da, db)
                    self.assertTrue(p)
                    msg = '{} <-> {}'.format(a, b)
                    # assertAlmostEqualRelError converts second to first
                    self.assertAlmostEqualRelError(b, a, rel=.01, msg=msg)

        for a, b in itertools.product(eq, eq):
            self.assertAlmostEqualRelError(a.to(b.units, 'sp'),
                                           b,
                                           rel=.01,
                                           msg=msg)