From fc34f30406aacb0206f56c650e17f5b8945b5a2d Mon Sep 17 00:00:00 2001 From: Irvine <81997674+1rvine@users.noreply.github.com> Date: Mon, 8 Aug 2022 19:56:21 -0700 Subject: [PATCH 1/2] Changed assertions and fixtures --- tests/test_core.py | 26 +-- tests/test_opentime.py | 435 +++++++++++++++++++++-------------------- 2 files changed, 241 insertions(+), 220 deletions(-) diff --git a/tests/test_core.py b/tests/test_core.py index 55a895a891..17ce1a3591 100644 --- a/tests/test_core.py +++ b/tests/test_core.py @@ -5,17 +5,17 @@ import shutil import tempfile import unittest +import pytest import opentimelineio as otio class TestCoreFunctions(unittest.TestCase): - def setUp(self): - self.tmpDir = tempfile.mkdtemp() - - def tearDown(self): - shutil.rmtree(self.tmpDir) - + + @pytest.fixture() + def dir(): + return tempfile.mkdtemp() + def test_deserialize_json_from_file_errors(self): """Verify that the bindings return the correct errors based on the errno""" if sys.version_info[0] < 3: @@ -25,7 +25,8 @@ def test_deserialize_json_from_file_errors(self): with self.assertRaises(excType) as exc: otio.core.deserialize_json_from_file('non-existent-file-here') - self.assertIsInstance(exc.exception, excType) + assert (exc.exception, excType) + @unittest.skipUnless(not sys.platform.startswith("win"), "requires non Windows sytem") # noqa def test_serialize_json_to_file_errors_non_windows(self): @@ -36,8 +37,9 @@ def test_serialize_json_to_file_errors_non_windows(self): excType = IsADirectoryError # noqa: F821 with self.assertRaises(excType) as exc: - otio.core.serialize_json_to_file({}, self.tmpDir) - self.assertIsInstance(exc.exception, excType) + otio.core.serialize_json_to_file({}, tempfile.mkdtemp()) + assert (exc.exception, excType) + @unittest.skipUnless(sys.platform.startswith("win"), "requires Windows") def test_serialize_json_to_file_errors_windows(self): @@ -48,5 +50,7 @@ def test_serialize_json_to_file_errors_windows(self): excType = PermissionError # noqa: F821 with self.assertRaises(excType) as exc: - otio.core.serialize_json_to_file({}, self.tmpDir) - self.assertIsInstance(exc.exception, excType) + otio.core.serialize_json_to_file({}, dir()) + assert (exc.exception, excType) +def myTestCoreFunctions(): + return diff --git a/tests/test_opentime.py b/tests/test_opentime.py index 309dbe2549..41ff10bf64 100755 --- a/tests/test_opentime.py +++ b/tests/test_opentime.py @@ -14,63 +14,64 @@ class TestTime(unittest.TestCase): def test_create(self): t_val = 30.2 t = otio.opentime.RationalTime(t_val) - self.assertIsNotNone(t) - self.assertEqual(t.value, t_val) + assert (t is not None) + assert (t.value == t_val) t = otio.opentime.RationalTime() - self.assertEqual(t.value, 0) - self.assertEqual(t.rate, 1.0) + assert (t.value == 0) + assert (t.rate == 1.0) def test_equality(self): t1 = otio.opentime.RationalTime(30.2) - self.assertEqual(t1, t1) + assert (t1 == t1) t2 = otio.opentime.RationalTime(30.2) - self.assertTrue(t1 is not t2) - self.assertEqual(t1, t2) + assert (t1 is not t2) + assert (t1 == t2) def test_inequality(self): t1 = otio.opentime.RationalTime(30.2) - self.assertEqual(t1, t1) + assert (t1 == t1) t2 = otio.opentime.RationalTime(33.2) - self.assertTrue(t1 is not t2) - self.assertNotEqual(t1, t2) + assert (t1 is not t2) + assert (t1 != t2) + t3 = otio.opentime.RationalTime(30.2) - self.assertTrue(t1 is not t3) - self.assertFalse(t1 != t3) + assert (t1 is not t3) + assert (t1 != t3) == False def test_comparison(self): t1 = otio.opentime.RationalTime(15.2) t2 = otio.opentime.RationalTime(15.6) - self.assertTrue(t1 < t2) - self.assertTrue(t1 <= t2) - self.assertFalse(t1 > t2) - self.assertFalse(t1 >= t2) + assert (t1 < t2) + assert (t1 <= t2) + assert (t1 > t2) == False + assert (t1 >= t2) == False # Ensure the equality case of the comparisons works correctly t3 = otio.opentime.RationalTime(30.4, 2) - self.assertTrue(t1 <= t3) - self.assertTrue(t1 >= t3) - self.assertTrue(t3 <= t1) - self.assertTrue(t3 >= t1) + assert(t1 <= t3) + assert (t1>=t3) + assert(t3<=t1) + assert(t3>=t1) # test implicit base conversion t2 = otio.opentime.RationalTime(15.6, 48) - self.assertTrue(t1 > t2) - self.assertTrue(t1 >= t2) - self.assertFalse(t1 < t2) - self.assertFalse(t1 <= t2) + assert(t1>t2) + assert(t1>=t2) + assert(t1 Date: Tue, 16 Aug 2022 14:22:40 -0700 Subject: [PATCH 2/2] Fixed lint issues --- tests/test_core.py | 41 ++- tests/test_opentime.py | 740 +++++++++++++++++++---------------------- 2 files changed, 353 insertions(+), 428 deletions(-) diff --git a/tests/test_core.py b/tests/test_core.py index 17ce1a3591..998df3011d 100644 --- a/tests/test_core.py +++ b/tests/test_core.py @@ -2,20 +2,13 @@ # Copyright Contributors to the OpenTimelineIO project import sys -import shutil import tempfile -import unittest import pytest import opentimelineio as otio -class TestCoreFunctions(unittest.TestCase): - - @pytest.fixture() - def dir(): - return tempfile.mkdtemp() - +class TestCoreFunctions: def test_deserialize_json_from_file_errors(self): """Verify that the bindings return the correct errors based on the errno""" if sys.version_info[0] < 3: @@ -23,12 +16,13 @@ def test_deserialize_json_from_file_errors(self): else: excType = FileNotFoundError # noqa: F821 - with self.assertRaises(excType) as exc: - otio.core.deserialize_json_from_file('non-existent-file-here') - assert (exc.exception, excType) + with pytest.raises(excType) as exc: + otio.core.deserialize_json_from_file("non-existent-file-here") + assert isinstance(exc.exception, excType) - - @unittest.skipUnless(not sys.platform.startswith("win"), "requires non Windows sytem") # noqa + @pytest.mark.skipif( + not sys.platform.startswith("win"), reason="requires non Windows sytem" + ) # noqa def test_serialize_json_to_file_errors_non_windows(self): """Verify that the bindings return the correct errors based on the errno""" if sys.version_info[0] < 3: @@ -36,12 +30,11 @@ def test_serialize_json_to_file_errors_non_windows(self): else: excType = IsADirectoryError # noqa: F821 - with self.assertRaises(excType) as exc: + with pytest.raises(excType) as exc: otio.core.serialize_json_to_file({}, tempfile.mkdtemp()) - assert (exc.exception, excType) - + assert isinstance(exc.exception, excType) - @unittest.skipUnless(sys.platform.startswith("win"), "requires Windows") + @pytest.mark.skipif(not sys.platform.startswith("win"), reason="requires Windows") def test_serialize_json_to_file_errors_windows(self): """Verify that the bindings return the correct errors based on the errno""" if sys.version_info[0] < 3: @@ -49,8 +42,14 @@ def test_serialize_json_to_file_errors_windows(self): else: excType = PermissionError # noqa: F821 - with self.assertRaises(excType) as exc: - otio.core.serialize_json_to_file({}, dir()) - assert (exc.exception, excType) + with pytest.raises(excType) as exc: + otio.core.serialize_json_to_file({}, tempfile.mkdtemp()) + assert isinstance(exc.exception, excType) + + def myTestCoreFunctions(): - return + return + + +# SPDX-License-Identifier: Apache-2.0 +# Copyright Contributors to the OpenTimelineIO project diff --git a/tests/test_opentime.py b/tests/test_opentime.py index 41ff10bf64..22640299c3 100755 --- a/tests/test_opentime.py +++ b/tests/test_opentime.py @@ -2,76 +2,74 @@ # Copyright Contributors to the OpenTimelineIO project """Test Harness for the otio.opentime library.""" - -import opentimelineio as otio - import unittest import copy +import pytest +import opentimelineio as otio class TestTime(unittest.TestCase): - def test_create(self): t_val = 30.2 t = otio.opentime.RationalTime(t_val) - assert (t is not None) - assert (t.value == t_val) + assert t is not None + assert t.value == t_val t = otio.opentime.RationalTime() - assert (t.value == 0) - assert (t.rate == 1.0) + assert t.value == 0 + assert t.rate == 1.0 def test_equality(self): t1 = otio.opentime.RationalTime(30.2) - assert (t1 == t1) + assert t1 == t1 t2 = otio.opentime.RationalTime(30.2) - assert (t1 is not t2) - assert (t1 == t2) + assert t1 is not t2 + assert t1 == t2 def test_inequality(self): t1 = otio.opentime.RationalTime(30.2) - assert (t1 == t1) + assert t1 == t1 t2 = otio.opentime.RationalTime(33.2) - assert (t1 is not t2) - assert (t1 != t2) - + assert t1 is not t2 + assert t1 != t2 + t3 = otio.opentime.RationalTime(30.2) - assert (t1 is not t3) - assert (t1 != t3) == False + assert t1 is not t3 + assert (t1 != t3) is False def test_comparison(self): t1 = otio.opentime.RationalTime(15.2) t2 = otio.opentime.RationalTime(15.6) - assert (t1 < t2) - assert (t1 <= t2) - assert (t1 > t2) == False - assert (t1 >= t2) == False + assert t1 < t2 + assert t1 <= t2 + assert (t1 > t2) is False + assert (t1 >= t2) is False # Ensure the equality case of the comparisons works correctly t3 = otio.opentime.RationalTime(30.4, 2) - assert(t1 <= t3) - assert (t1>=t3) - assert(t3<=t1) - assert(t3>=t1) + assert t1 <= t3 + assert t1 >= t3 + assert t3 <= t1 + assert t3 >= t1 # test implicit base conversion t2 = otio.opentime.RationalTime(15.6, 48) - assert(t1>t2) - assert(t1>=t2) - assert(t1 t2 + assert t1 >= t2 + assert (t1 < t2) is False + assert (t1 <= t2) is False def test_copy(self): t1 = otio.opentime.RationalTime(18, 24) t2 = copy.copy(t1) - assert (t2 == otio.opentime.RationalTime(18,24)) + assert t2 == otio.opentime.RationalTime(18, 24) def test_deepcopy(self): t1 = otio.opentime.RationalTime(18, 24) t2 = copy.deepcopy(t1) - assert (t2 == otio.opentime.RationalTime(18,24)) + assert t2 == otio.opentime.RationalTime(18, 24) def test_base_conversion(self): @@ -79,24 +77,24 @@ def test_base_conversion(self): t = otio.opentime.RationalTime(10, 24) with self.assertRaises(TypeError): t.rescaled_to("foo") - assert (t.rate == 24) + assert t.rate == 24 t = t.rescaled_to(48) - assert (t.rate == 48) + assert t.rate == 48 # from another RationalTime t = otio.opentime.RationalTime(10, 24) t2 = otio.opentime.RationalTime(20, 48) t = t.rescaled_to(t2) - assert (t.rate == t2.rate) + assert t.rate == t2.rate def test_time_timecode_convert(self): timecode = "00:06:56:17" t = otio.opentime.from_timecode(timecode, 24) - assert (timecode == otio.opentime.to_timecode(t)) + assert timecode == otio.opentime.to_timecode(t) def test_time_timecode_convert_bad_rate(self): with self.assertRaises(ValueError) as exception_manager: - otio.opentime.from_timecode('01:00:13:24', 24) + otio.opentime.from_timecode("01:00:13:24", 24) exc_message = str(exception_manager.exception) self.assertEqual( @@ -107,25 +105,23 @@ def test_time_timecode_convert_bad_rate(self): def test_timecode_24(self): timecode = "00:00:01:00" t = otio.opentime.RationalTime(value=24, rate=24) - assert (t == otio.opentime.from_timecode(timecode,24)) + assert t == otio.opentime.from_timecode(timecode, 24) timecode = "00:01:00:00" t = otio.opentime.RationalTime(value=24 * 60, rate=24) - assert (t == otio.opentime.from_timecode(timecode,24)) + assert t == otio.opentime.from_timecode(timecode, 24) timecode = "01:00:00:00" t = otio.opentime.RationalTime(value=24 * 60 * 60, rate=24) - assert (t == otio.opentime.from_timecode(timecode,24)) + assert t == otio.opentime.from_timecode(timecode, 24) timecode = "24:00:00:00" t = otio.opentime.RationalTime(value=24 * 60 * 60 * 24, rate=24) - assert (t == otio.opentime.from_timecode(timecode,24)) - + assert t == otio.opentime.from_timecode(timecode, 24) timecode = "23:59:59:23" t = otio.opentime.RationalTime(value=24 * 60 * 60 * 24 - 1, rate=24) - assert (t == otio.opentime.from_timecode(timecode,24)) - + assert t == otio.opentime.from_timecode(timecode, 24) def test_plus_equals(self): sum1 = otio.opentime.RationalTime() @@ -136,68 +132,58 @@ def test_plus_equals(self): sum1 += incr sum2 = sum2 + incr - assert (sum1 == sum2) + assert sum1 == sum2 def test_time_timecode_zero(self): t = otio.opentime.RationalTime() timecode = "00:00:00:00" - assert (timecode == otio.opentime.to_timecode(t,24)) - assert (t == otio.opentime.from_timecode(timecode,24)) - + assert timecode == otio.opentime.to_timecode(t, 24) + assert t == otio.opentime.from_timecode(timecode, 24) def test_long_running_timecode_24(self): final_frame_number = 24 * 60 * 60 * 24 - 1 final_time = otio.opentime.from_frames(final_frame_number, 24) - self.assertEqual( - otio.opentime.to_timecode(final_time), - "23:59:59:23" - ) + self.assertEqual(otio.opentime.to_timecode(final_time), "23:59:59:23") step_time = otio.opentime.RationalTime(value=1, rate=24) # fetching this test function from the c++ module directly cumulative_time = otio._opentime._testing.add_many( - step_time, - final_frame_number + step_time, final_frame_number ) - assert (cumulative_time == final_time) + assert cumulative_time == final_time # Adding by a non-multiple of 24 for fnum in range(1113, final_frame_number, 1113): rt = otio.opentime.from_frames(fnum, 24) tc = otio.opentime.to_timecode(rt) rt2 = otio.opentime.from_timecode(tc, 24) - assert (rt == rt2) - assert (tc == otio.opentime.to_timecode(rt2)) + assert rt == rt2 + assert tc == otio.opentime.to_timecode(rt2) def test_timecode_23976_fps(self): # This should behave exactly like 24 fps timecode = "00:00:01:00" t = otio.opentime.RationalTime(value=24, rate=23.976) - assert (t == otio.opentime.from_timecode(timecode, 23.976)) + assert t == otio.opentime.from_timecode(timecode, 23.976) timecode = "00:01:00:00" t = otio.opentime.RationalTime(value=24 * 60, rate=23.976) - assert (t == otio.opentime.from_timecode(timecode, 23.976)) - + assert t == otio.opentime.from_timecode(timecode, 23.976) timecode = "01:00:00:00" t = otio.opentime.RationalTime(value=24 * 60 * 60, rate=23.976) - assert (t == otio.opentime.from_timecode(timecode, 23.976)) + assert t == otio.opentime.from_timecode(timecode, 23.976) timecode = "24:00:00:00" t = otio.opentime.RationalTime(value=24 * 60 * 60 * 24, rate=23.976) - assert (t == otio.opentime.from_timecode(timecode, 23.976)) - + assert t == otio.opentime.from_timecode(timecode, 23.976) timecode = "23:59:59:23" t = otio.opentime.RationalTime( - value=24 * 60 * 60 * 24 - 1, - rate=(24000 / 1001.0) - ) - self.assertEqual( - t, otio.opentime.from_timecode(timecode, (24000 / 1001.0)) + value=24 * 60 * 60 * 24 - 1, rate=(24000 / 1001.0) ) + self.assertEqual(t, otio.opentime.from_timecode(timecode, (24000 / 1001.0))) def test_converting_negative_values_to_timecode(self): t = otio.opentime.RationalTime(value=-1, rate=25) @@ -219,106 +205,94 @@ def test_dropframe_timecode_2997fps(self): (fps * seconds + frames - dropframes * (minutes - minutes / 10)) """ test_values = { - 'first_four_frames': [ - (0, '00:00:00;00'), - (1, '00:00:00;01'), - (2, '00:00:00;02'), - (3, '00:00:00;03') + "first_four_frames": [ + (0, "00:00:00;00"), + (1, "00:00:00;01"), + (2, "00:00:00;02"), + (3, "00:00:00;03"), ], - - 'first_minute_rollover': [ - (30 * 59 + 29, '00:00:59;29'), - (30 * 59 + 30, '00:01:00;02'), - (30 * 59 + 31, '00:01:00;03'), - (30 * 59 + 32, '00:01:00;04'), - (30 * 59 + 33, '00:01:00;05') + "first_minute_rollover": [ + (30 * 59 + 29, "00:00:59;29"), + (30 * 59 + 30, "00:01:00;02"), + (30 * 59 + 31, "00:01:00;03"), + (30 * 59 + 32, "00:01:00;04"), + (30 * 59 + 33, "00:01:00;05"), ], - - 'fift_minute': [ - (30 * 299 + 29 - 2 * 4, '00:04:59;29'), - (30 * 299 + 30 - 2 * 4, '00:05:00;02'), - (30 * 299 + 31 - 2 * 4, '00:05:00;03'), - (30 * 299 + 32 - 2 * 4, '00:05:00;04'), - (30 * 299 + 33 - 2 * 4, '00:05:00;05') + "fift_minute": [ + (30 * 299 + 29 - 2 * 4, "00:04:59;29"), + (30 * 299 + 30 - 2 * 4, "00:05:00;02"), + (30 * 299 + 31 - 2 * 4, "00:05:00;03"), + (30 * 299 + 32 - 2 * 4, "00:05:00;04"), + (30 * 299 + 33 - 2 * 4, "00:05:00;05"), ], - - 'seventh_minute': [ - (30 * 419 + 29 - 2 * 6, '00:06:59;29'), - (30 * 419 + 30 - 2 * 6, '00:07:00;02'), - (30 * 419 + 31 - 2 * 6, '00:07:00;03'), - (30 * 419 + 32 - 2 * 6, '00:07:00;04'), - (30 * 419 + 33 - 2 * 6, '00:07:00;05') + "seventh_minute": [ + (30 * 419 + 29 - 2 * 6, "00:06:59;29"), + (30 * 419 + 30 - 2 * 6, "00:07:00;02"), + (30 * 419 + 31 - 2 * 6, "00:07:00;03"), + (30 * 419 + 32 - 2 * 6, "00:07:00;04"), + (30 * 419 + 33 - 2 * 6, "00:07:00;05"), ], - - 'tenth_minute': [ - (30 * 599 + 29 - 2 * (10 - 10 // 10), '00:09:59;29'), - (30 * 599 + 30 - 2 * (10 - 10 // 10), '00:10:00;00'), - (30 * 599 + 31 - 2 * (10 - 10 // 10), '00:10:00;01'), - (30 * 599 + 32 - 2 * (10 - 10 // 10), '00:10:00;02'), - (30 * 599 + 33 - 2 * (10 - 10 // 10), '00:10:00;03') + "tenth_minute": [ + (30 * 599 + 29 - 2 * (10 - 10 // 10), "00:09:59;29"), + (30 * 599 + 30 - 2 * (10 - 10 // 10), "00:10:00;00"), + (30 * 599 + 31 - 2 * (10 - 10 // 10), "00:10:00;01"), + (30 * 599 + 32 - 2 * (10 - 10 // 10), "00:10:00;02"), + (30 * 599 + 33 - 2 * (10 - 10 // 10), "00:10:00;03"), ], - - 'second_hour': [ - (30 * 7199 + 29 - 2 * (120 - 120 // 10), '01:59:59;29'), - (30 * 7199 + 30 - 2 * (120 - 120 // 10), '02:00:00;00'), - (30 * 7199 + 31 - 2 * (120 - 120 // 10), '02:00:00;01'), - (30 * 7199 + 32 - 2 * (120 - 120 // 10), '02:00:00;02'), - (30 * 7199 + 33 - 2 * (120 - 120 // 10), '02:00:00;03') + "second_hour": [ + (30 * 7199 + 29 - 2 * (120 - 120 // 10), "01:59:59;29"), + (30 * 7199 + 30 - 2 * (120 - 120 // 10), "02:00:00;00"), + (30 * 7199 + 31 - 2 * (120 - 120 // 10), "02:00:00;01"), + (30 * 7199 + 32 - 2 * (120 - 120 // 10), "02:00:00;02"), + (30 * 7199 + 33 - 2 * (120 - 120 // 10), "02:00:00;03"), ], - - 'second_and_a_half_hour': [ - (30 * 8999 + 29 - 2 * (150 - 150 // 10), '02:29:59;29'), - (30 * 8999 + 30 - 2 * (150 - 150 // 10), '02:30:00;00'), - (30 * 8999 + 31 - 2 * (150 - 150 // 10), '02:30:00;01'), - (30 * 8999 + 32 - 2 * (150 - 150 // 10), '02:30:00;02'), - (30 * 8999 + 33 - 2 * (150 - 150 // 10), '02:30:00;03') + "second_and_a_half_hour": [ + (30 * 8999 + 29 - 2 * (150 - 150 // 10), "02:29:59;29"), + (30 * 8999 + 30 - 2 * (150 - 150 // 10), "02:30:00;00"), + (30 * 8999 + 31 - 2 * (150 - 150 // 10), "02:30:00;01"), + (30 * 8999 + 32 - 2 * (150 - 150 // 10), "02:30:00;02"), + (30 * 8999 + 33 - 2 * (150 - 150 // 10), "02:30:00;03"), ], - - 'tenth_hour': [ - (30 * 35999 + 29 - 2 * (600 - 600 // 10), '09:59:59;29'), - (30 * 35999 + 30 - 2 * (600 - 600 // 10), '10:00:00;00'), - (30 * 35999 + 31 - 2 * (600 - 600 // 10), '10:00:00;01'), - (30 * 35999 + 32 - 2 * (600 - 600 // 10), '10:00:00;02'), - (30 * 35999 + 33 - 2 * (600 - 600 // 10), '10:00:00;03') + "tenth_hour": [ + (30 * 35999 + 29 - 2 * (600 - 600 // 10), "09:59:59;29"), + (30 * 35999 + 30 - 2 * (600 - 600 // 10), "10:00:00;00"), + (30 * 35999 + 31 - 2 * (600 - 600 // 10), "10:00:00;01"), + (30 * 35999 + 32 - 2 * (600 - 600 // 10), "10:00:00;02"), + (30 * 35999 + 33 - 2 * (600 - 600 // 10), "10:00:00;03"), ], - # Since 3 minutes < 10, we subtract 1 from 603 minutes - 'tenth_hour_third minute': [ - (30 * 36179 + 29 - 2 * (602 - 602 // 10), '10:02:59;29'), - (30 * 36179 + 30 - 2 * (602 - 602 // 10), '10:03:00;02'), - (30 * 36179 + 31 - 2 * (602 - 602 // 10), '10:03:00;03'), - (30 * 36179 + 32 - 2 * (602 - 602 // 10), '10:03:00;04'), - (30 * 36179 + 33 - 2 * (602 - 602 // 10), '10:03:00;05') - ] + "tenth_hour_third minute": [ + (30 * 36179 + 29 - 2 * (602 - 602 // 10), "10:02:59;29"), + (30 * 36179 + 30 - 2 * (602 - 602 // 10), "10:03:00;02"), + (30 * 36179 + 31 - 2 * (602 - 602 // 10), "10:03:00;03"), + (30 * 36179 + 32 - 2 * (602 - 602 // 10), "10:03:00;04"), + (30 * 36179 + 33 - 2 * (602 - 602 // 10), "10:03:00;05"), + ], } for time_key, time_values in test_values.items(): for value, tc in time_values: t = otio.opentime.RationalTime(value, 29.97) self.assertEqual( - tc, otio.opentime.to_timecode( - t, rate=29.97, drop_frame=True - ) + tc, otio.opentime.to_timecode(t, rate=29.97, drop_frame=True) ) t1 = otio.opentime.from_timecode(tc, rate=29.97) - self.assertEqual(t, t1) + assert t == t1 def test_timecode_ntsc_2997fps(self): frames = 1084319 - rate_float = (30000 / 1001.0) + rate_float = 30000 / 1001.0 t = otio.opentime.RationalTime(frames, rate_float) dftc = otio.opentime.to_timecode(t, rate_float, drop_frame=True) - assert (dftc == '10:03:00;05') + assert dftc == "10:03:00;05" tc = otio.opentime.to_timecode(t, rate_float, drop_frame=False) - assert (tc == '10:02:23:29') - + assert tc == "10:02:23:29" # Detect DFTC from rate for backward compatability with old versions tc_auto = otio.opentime.to_timecode(t, rate_float) - assert (tc_auto == '10:03:00;05') - + assert tc_auto == "10:03:00;05" invalid_df_rate = otio.opentime.RationalTime(30, (24000 / 1001.0)) with self.assertRaises(ValueError): @@ -328,12 +302,12 @@ def test_timecode_ntsc_2997fps(self): def test_timecode_2997(self): ref_values = [ - (10789, '00:05:59:19', '00:05:59;29'), - (10790, '00:05:59:20', '00:06:00;02'), - (17981, '00:09:59:11', '00:09:59;29'), - (17982, '00:09:59:12', '00:10:00;00'), - (17983, '00:09:59:13', '00:10:00;01'), - (17984, '00:09:59:14', '00:10:00;02'), + (10789, "00:05:59:19", "00:05:59;29"), + (10790, "00:05:59:20", "00:06:00;02"), + (17981, "00:09:59:11", "00:09:59;29"), + (17982, "00:09:59:12", "00:10:00;00"), + (17983, "00:09:59:13", "00:10:00;01"), + (17984, "00:09:59:14", "00:10:00;02"), ] for value, tc, dftc in ref_values: @@ -343,18 +317,18 @@ def test_timecode_2997(self): to_auto_tc = otio.opentime.to_timecode(t, rate=29.97) # 29.97 should auto-detect dftc for backward compatability - assert (to_dftc == to_auto_tc) + assert to_dftc == to_auto_tc # check calculated against reference - assert (to_dftc == dftc) - assert (tc == to_tc) + assert to_dftc == dftc + assert tc == to_tc # Check they convert back t1 = otio.opentime.from_timecode(to_dftc, rate=29.97) - assert (t1 == t) + assert t1 == t t2 = otio.opentime.from_timecode(to_tc, rate=29.97) - assert (t2 == t) + assert t2 == t def test_faulty_formatted_timecode_24(self): """ @@ -371,7 +345,7 @@ def test_faulty_formatted_timecode_24(self): 'INVALID_RATE_FOR_DROP_FRAME_TIMECODE'. """ with self.assertRaises(ValueError): - otio.opentime.from_timecode('01:00:13;23', 24) + otio.opentime.from_timecode("01:00:13;23", 24) def test_invalid_rate_to_timecode_functions(self): t = otio.opentime.RationalTime(100, 29.98) @@ -387,65 +361,59 @@ def test_time_string_24(self): time_string = "00:00:00.041667" t = otio.opentime.RationalTime(value=1.0, rate=24) time_obj = otio.opentime.from_time_string(time_string, 24) - assert (t.almost_equal(time_obj, delta = 0.001)) - assert (time_obj.rate == 24) + assert t.almost_equal(time_obj, delta=0.001) + assert time_obj.rate == 24 time_string = "00:00:01" t = otio.opentime.RationalTime(value=24, rate=24) time_obj = otio.opentime.from_time_string(time_string, 24) - assert (t.almost_equal(time_obj, delta = 0.001)) - + assert t.almost_equal(time_obj, delta=0.001) time_string = "00:01:00" t = otio.opentime.RationalTime(value=24 * 60, rate=24) time_obj = otio.opentime.from_time_string(time_string, 24) - assert (t.almost_equal(time_obj, delta = 0.001)) - + assert t.almost_equal(time_obj, delta=0.001) time_string = "01:00:00" t = otio.opentime.RationalTime(value=24 * 60 * 60, rate=24) time_obj = otio.opentime.from_time_string(time_string, 24) - assert (t.almost_equal(time_obj, delta = 0.001)) - + assert t.almost_equal(time_obj, delta=0.001) time_string = "24:00:00" t = otio.opentime.RationalTime(value=24 * 60 * 60 * 24, rate=24) time_obj = otio.opentime.from_time_string(time_string, 24) - assert (t.almost_equal(time_obj, delta = 0.001)) + assert t.almost_equal(time_obj, delta=0.001) time_string = "23:59:59.958333" t = otio.opentime.RationalTime(value=24 * 60 * 60 * 24 - 1, rate=24) time_obj = otio.opentime.from_time_string(time_string, 24) - assert (t.almost_equal(time_obj, delta = 0.001)) - - + assert t.almost_equal(time_obj, delta=0.001) def test_time_string_25(self): time_string = "00:00:01" t = otio.opentime.RationalTime(value=25, rate=25) time_obj = otio.opentime.from_time_string(time_string, 25) - assert (t.almost_equal(time_obj, delta = 0.001)) - + assert t.almost_equal(time_obj, delta=0.001) time_string = "00:01:00" t = otio.opentime.RationalTime(value=25 * 60, rate=25) time_obj = otio.opentime.from_time_string(time_string, 25) - assert (t.almost_equal(time_obj, delta = 0.001)) + assert t.almost_equal(time_obj, delta=0.001) time_string = "01:00:00" t = otio.opentime.RationalTime(value=25 * 60 * 60, rate=25) time_obj = otio.opentime.from_time_string(time_string, 25) - assert (t.almost_equal(time_obj, delta = 0.001)) + assert t.almost_equal(time_obj, delta=0.001) time_string = "24:00:00" t = otio.opentime.RationalTime(value=25 * 60 * 60 * 24, rate=25) time_obj = otio.opentime.from_time_string(time_string, 25) - assert (t.almost_equal(time_obj, delta = 0.001)) + assert t.almost_equal(time_obj, delta=0.001) time_string = "23:59:59.92" t = otio.opentime.RationalTime(value=25 * 60 * 60 * 24 - 2, rate=25) time_obj = otio.opentime.from_time_string(time_string, 25) - assert (t.almost_equal(time_obj, delta = 0.001)) + assert t.almost_equal(time_obj, delta=0.001) def test_time_time_string_negative_rational_time(self): """ @@ -456,14 +424,14 @@ def test_time_time_string_negative_rational_time(self): baseline_time_string = "-00:00:01.0" rt = otio.opentime.RationalTime(-24, 24) time_string = otio.opentime.to_time_string(rt) - assert (baseline_time_string == time_string) + assert baseline_time_string == time_string def test_time_time_string_zero(self): t = otio.opentime.RationalTime() time_string = "00:00:00.0" time_obj = otio.opentime.from_time_string(time_string, 24) - assert (time_string == otio.opentime.to_time_string(t)) - assert (t.almost_equal(time_obj, delta = 0.001)) + assert time_string == otio.opentime.to_time_string(t) + assert t.almost_equal(time_obj, delta=0.001) def test_to_time_string_microseconds_starts_with_zero(self): # this number has a leading 0 in the fractional part when converted to @@ -471,179 +439,173 @@ def test_to_time_string_microseconds_starts_with_zero(self): rt = otio.opentime.RationalTime(2090, 24) self.assertEqual( str(rt), - str(otio.opentime.from_time_string(otio.opentime.to_time_string(rt), 24)) + str(otio.opentime.from_time_string(otio.opentime.to_time_string(rt), 24)), ) def test_long_running_time_string_24(self): final_frame_number = 24 * 60 * 60 * 24 - 1 final_time = otio.opentime.from_frames(final_frame_number, 24) - self.assertEqual( - otio.opentime.to_time_string(final_time), - "23:59:59.958333" - ) + self.assertEqual(otio.opentime.to_time_string(final_time), "23:59:59.958333") step_time = otio.opentime.RationalTime(value=1, rate=24) cumulative_time = otio._opentime._testing.add_many( - step_time, - final_frame_number + step_time, final_frame_number ) - assert(cumulative_time.almost_equal(final_time, delta = 0.001)) + assert cumulative_time.almost_equal(final_time, delta=0.001) # Adding by a non-multiple of 24 for fnum in range(1113, final_frame_number, 1113): rt = otio.opentime.from_frames(fnum, 24) tc = otio.opentime.to_time_string(rt) rt2 = otio.opentime.from_time_string(tc, 24) - assert (rt == rt2) - assert (tc == otio.opentime.to_time_string(rt2)) + assert rt == rt2 + assert tc == otio.opentime.to_time_string(rt2) def test_time_string_23976_fps(self): # This list is rewritten from conversion into seconds of # test_timecode_23976_fps ref_values_23976 = [ - (1025, '00:00:01.708333'), - (179900, '00:04:59.833333'), - (180000, '00:05:00.0'), - (360000, '00:10:00.0'), - (720000, '00:20:00.0'), - (1079300, '00:29:58.833333'), - (1080000, '00:30:00.0'), - (1080150, '00:30:00.25'), - (1440000, '00:40:00.0'), - (1800000, '00:50:00.0'), - (1978750, '00:54:57.916666'), - (1980000, '00:55:00.0'), - (46700, '00:01:17.833333'), - (225950, '00:06:16.583333'), - (436400, '00:12:07.333333'), - (703350, '00:19:32.25') + (1025, "00:00:01.708333"), + (179900, "00:04:59.833333"), + (180000, "00:05:00.0"), + (360000, "00:10:00.0"), + (720000, "00:20:00.0"), + (1079300, "00:29:58.833333"), + (1080000, "00:30:00.0"), + (1080150, "00:30:00.25"), + (1440000, "00:40:00.0"), + (1800000, "00:50:00.0"), + (1978750, "00:54:57.916666"), + (1980000, "00:55:00.0"), + (46700, "00:01:17.833333"), + (225950, "00:06:16.583333"), + (436400, "00:12:07.333333"), + (703350, "00:19:32.25"), ] for value, ts in ref_values_23976: t = otio.opentime.RationalTime(value, 600) - assert (ts == otio.opentime.to_time_string(t)) + assert ts == otio.opentime.to_time_string(t) # t1 = otio.opentime.from_time_string(ts, rate=23.976) # fails due to precision issues # self.assertEqual(t, t1) def test_time_to_string(self): t = otio.opentime.RationalTime(1.0, 2.0) - assert (str(t),"RationalTime(1,2)") - self.assertEqual( - repr(t), - "otio.opentime.RationalTime(value=1, rate=2)" - ) + assert str(t), "RationalTime(1,2)" + self.assertEqual(repr(t), "otio.opentime.RationalTime(value=1, rate=2)") def test_frames_with_int_fps(self): for fps in (24, 30, 48, 60): t1 = otio.opentime.from_frames(101, fps) t2 = otio.opentime.RationalTime(101, fps) - assert (t1,t2) + assert t1 == t2 def test_frames_with_nonint_fps(self): for fps in (23.98, 29.97, 59.94): t1 = otio.opentime.from_frames(101, fps) t2 = otio.opentime.RationalTime(101, fps) - assert (t1,t2) + assert t1 == t2 def test_seconds(self): s1 = 1834 t1 = otio.opentime.from_seconds(s1) - assert (t1.value == 1834) - assert (t1.rate == 1) + assert t1.value == 1834 + assert t1.rate == 1 t1_as_seconds = otio.opentime.to_seconds(t1) - assert (t1_as_seconds == s1) - assert (float(t1.value) / t1.rate, s1) + assert t1_as_seconds == s1 + assert (float(t1.value) / t1.rate) == pytest.approx(s1) s2 = 248474.345 t2 = otio.opentime.from_seconds(s2) - assert (t2.value, s2) - assert (t2.rate, 1.0) + assert t2.value == pytest.approx(s2) + assert t2.rate == pytest.approx(1.0) t2_as_seconds = otio.opentime.to_seconds(t2) - assert (s2, t2_as_seconds) - assert (float(t2.value) / t2.rate, s2) + assert s2 == pytest.approx(t2_as_seconds) + assert (float(t2.value) / t2.rate) == pytest.approx(s2) v3 = 3459 r3 = 24 s3 = float(3459) / 24 t3 = otio.opentime.RationalTime(v3, r3) t4 = otio.opentime.from_seconds(s3) - assert (otio.opentime.to_seconds(t3), s3) - assert (otio.opentime.to_seconds(t4), s3) + # assert (otio.opentime.to_seconds(t3), s3) + assert otio.opentime.to_seconds(t3) == pytest.approx(s3) + # assert (otio.opentime.to_seconds(t4), s3) + assert otio.opentime.to_seconds(t4) == pytest.approx(s3) t5 = otio.opentime.from_seconds(s3).rescaled_to(r3) t6 = otio.opentime.from_seconds(s3, r3) - assert (t5 == t6) - assert (t6.rate == r3) + assert t5 == t6 + assert t6.rate == r3 def test_duration(self): start_time = otio.opentime.from_frames(100, 24) end = otio.opentime.from_frames(200, 24) duration = otio.opentime.duration_from_start_end_time(start_time, end) - assert (duration == otio.opentime.from_frames(100,24)) + assert duration == otio.opentime.from_frames(100, 24) start_time = otio.opentime.from_frames(0, 1) end = otio.opentime.from_frames(200, 24) duration = otio.opentime.duration_from_start_end_time(start_time, end) - assert (duration == otio.opentime.from_frames(200,24)) + assert duration == otio.opentime.from_frames(200, 24) start_time = otio.opentime.from_frames(100, 24) end = otio.opentime.from_frames(200, 24) duration = otio.opentime.duration_from_start_end_time_inclusive(start_time, end) - assert (duration == otio.opentime.from_frames(101,24)) + assert duration == otio.opentime.from_frames(101, 24) start_time = otio.opentime.from_frames(0, 30) end = otio.opentime.from_frames(200, 24) duration = otio.opentime.duration_from_start_end_time_inclusive(start_time, end) - assert (duration == otio.opentime.from_frames(251,30)) + assert duration == otio.opentime.from_frames(251, 30) def test_math(self): a = otio.opentime.from_frames(100, 24) gap = otio.opentime.from_frames(50, 24) b = otio.opentime.from_frames(150, 24) - assert (b- a == gap) - assert (a+ gap ==b) - assert (b- gap == a) + assert (b - a) == gap + assert (a + gap) == b + assert (b - gap) == a with self.assertRaises(TypeError): b + "foo" a += gap - assert (a == b) + assert a == b a = otio.opentime.from_frames(100, 24) step = otio.opentime.from_frames(1, 24) for _ in range(50): a += step - assert (a == otio.opentime.from_frames(150, 24)) + assert a == otio.opentime.from_frames(150, 24) def test_math_with_different_scales(self): a = otio.opentime.from_frames(100, 24) gap = otio.opentime.from_frames(100, 48) b = otio.opentime.from_frames(75, 12) - assert (b-a == gap.rescaled_to(24)) - assert (a+gap == b.rescaled_to(48)) + assert (b - a) == gap.rescaled_to(24) + assert (a + gap) == b.rescaled_to(48) gap2 = copy.copy(gap) gap2 += a - assert (gap2 == a+gap) - assert (b-gap == a.rescaled_to(48)) + assert gap2 == (a + gap) + assert (b - gap) == a.rescaled_to(48) def test_duration_from_start_end_time(self): tend = otio.opentime.RationalTime(12, 25) tdur = otio.opentime.duration_from_start_end_time( - start_time=otio.opentime.RationalTime(0, 25), - end_time_exclusive=tend + start_time=otio.opentime.RationalTime(0, 25), end_time_exclusive=tend ) - assert (tend == tdur) + assert tend == tdur def test_subtract_with_different_rates(self): t1 = otio.opentime.RationalTime(12, 10) t2 = otio.opentime.RationalTime(12, 5) - assert ((t1-t2).value == -12) + assert (t1 - t2).value == -12 def test_incomparable_floats(self): t1 = otio.opentime.RationalTime(12, 10) @@ -661,23 +623,19 @@ def test_passing_ndf_tc_at_df_rate(self): NDF_TC = "00:59:58:17" frames = 107957 - tc1 = otio.opentime.to_timecode( - otio.opentime.RationalTime(frames, 29.97) - ) - assert (tc1 == DF_TC) + tc1 = otio.opentime.to_timecode(otio.opentime.RationalTime(frames, 29.97)) + assert tc1 == DF_TC tc2 = otio.opentime.to_timecode( - otio.opentime.RationalTime(frames, 29.97), - 29.97, - drop_frame=False + otio.opentime.RationalTime(frames, 29.97), 29.97, drop_frame=False ) - assert (tc2 == NDF_TC) + assert tc2 == NDF_TC t1 = otio.opentime.from_timecode(DF_TC, 29.97) - assert (t1.value, frames) + assert t1.value == frames t2 = otio.opentime.from_timecode(NDF_TC, 29.97) - assert (t2.value == frames) + assert t2.value == frames def test_nearest_valid_timecode_rate(self): invalid_valid_rates = ( @@ -691,60 +649,50 @@ def test_nearest_valid_timecode_rate(self): for invalid_rate, nearest_valid_rate in invalid_valid_rates: self.assertTrue( - otio.opentime.RationalTime.is_valid_timecode_rate( - nearest_valid_rate - ) + otio.opentime.RationalTime.is_valid_timecode_rate(nearest_valid_rate) ) self.assertEqual( - otio.opentime.RationalTime.nearest_valid_timecode_rate( - invalid_rate - ), + otio.opentime.RationalTime.nearest_valid_timecode_rate(invalid_rate), nearest_valid_rate, ) class TestTimeTransform(unittest.TestCase): - def test_identity_transform(self): tstart = otio.opentime.RationalTime(12, 25) txform = otio.opentime.TimeTransform() - assert (tstart == txform.applied_to(tstart)) + assert tstart == txform.applied_to(tstart) tstart = otio.opentime.RationalTime(12, 25) txform = otio.opentime.TimeTransform(rate=50) - assert (24 == txform.applied_to(tstart).value) + assert 24 == txform.applied_to(tstart).value def test_offset(self): tstart = otio.opentime.RationalTime(12, 25) toffset = otio.opentime.RationalTime(10, 25) txform = otio.opentime.TimeTransform(offset=toffset) - assert (tstart+ toffset == txform.applied_to(tstart)) + assert (tstart + toffset) == txform.applied_to(tstart) tr = otio.opentime.TimeRange(tstart, tstart) self.assertEqual( - txform.applied_to(tr), - otio.opentime.TimeRange(tstart + toffset, tstart) + txform.applied_to(tr), otio.opentime.TimeRange(tstart + toffset, tstart) ) def test_scale(self): tstart = otio.opentime.RationalTime(12, 25) txform = otio.opentime.TimeTransform(scale=2) - self.assertEqual( - otio.opentime.RationalTime(24, 25), - txform.applied_to(tstart) - ) + self.assertEqual(otio.opentime.RationalTime(24, 25), txform.applied_to(tstart)) tr = otio.opentime.TimeRange(tstart, tstart) tstart_scaled = otio.opentime.RationalTime(24, 25) self.assertEqual( - txform.applied_to(tr), - otio.opentime.TimeRange(tstart_scaled, tstart_scaled) + txform.applied_to(tr), otio.opentime.TimeRange(tstart_scaled, tstart_scaled) ) def test_rate(self): txform1 = otio.opentime.TimeTransform() txform2 = otio.opentime.TimeTransform(rate=50) - assert (txform2.rate == txform1.applied_to(txform2).rate) + assert txform2.rate == txform1.applied_to(txform2).rate def test_string(self): tstart = otio.opentime.RationalTime(12.0, 25.0) @@ -758,67 +706,59 @@ def test_string(self): "), " "scale=2, " "rate=-1" - ")" + ")", ) - self.assertEqual( - str(txform), - "TimeTransform(RationalTime(12, 25), 2, -1)" - ) + self.assertEqual(str(txform), "TimeTransform(RationalTime(12, 25), 2, -1)") def test_comparison(self): tstart = otio.opentime.RationalTime(12, 25) txform = otio.opentime.TimeTransform(offset=tstart, scale=2) tstart = otio.opentime.RationalTime(12, 25) txform2 = otio.opentime.TimeTransform(offset=tstart, scale=2) - assert (txform == txform2) - assert (txform != txform2) == False + assert txform == txform2 + assert (txform != txform2) is False tstart = otio.opentime.RationalTime(23, 25) txform3 = otio.opentime.TimeTransform(offset=tstart, scale=2) - assert (txform != txform3) - assert (txform == txform3) == False + assert txform != txform3 + assert (txform == txform3) is False def test_copy(self): tstart = otio.opentime.RationalTime(12, 25) t1 = otio.opentime.TimeTransform(tstart) t2 = copy.copy(t1) - assert (t1 == t2) - assert (t1 is not t2) - assert (t1.offset == t2.offset) + assert t1 == t2 + assert t1 is not t2 + assert t1.offset == t2.offset # TimeTransform.__copy__ acts as a deep copy - assert (t1.offset is not t2.offset) + assert t1.offset is not t2.offset def test_deepcopy(self): tstart = otio.opentime.RationalTime(12, 25) t1 = otio.opentime.TimeTransform(tstart) t2 = copy.deepcopy(t1) - assert (t1 == t2) - assert (t1 is not t2) - assert (t1.offset == t2.offset) + assert t1 == t2 + assert t1 is not t2 + assert t1.offset == t2.offset # TimeTransform.__copy__ acts as a deep copy - assert (t1.offset is not t2.offset) + assert t1.offset is not t2.offset class TestTimeRange(unittest.TestCase): - def test_create(self): tr = otio.opentime.TimeRange() blank = otio.opentime.RationalTime() - assert (tr.start_time == blank) - assert (tr.duration == blank) + assert tr.start_time == blank + assert tr.duration == blank - tr1 = otio.opentime.TimeRange( - start_time=otio.opentime.RationalTime(10, 48) - ) + tr1 = otio.opentime.TimeRange(start_time=otio.opentime.RationalTime(10, 48)) self.assertEqual(tr1.start_time.rate, tr1.duration.rate) - tr2 = otio.opentime.TimeRange( - duration=otio.opentime.RationalTime(10, 48) - ) - assert (tr2.start_time.rate == tr2.duration.rate) + tr2 = otio.opentime.TimeRange(duration=otio.opentime.RationalTime(10, 48)) + assert tr2.start_time.rate == tr2.duration.rate def test_duration_validation(self): tr = otio.opentime.TimeRange() @@ -829,44 +769,39 @@ def test_extended_by(self): # base 25 is just for testing # range starts at 0 and has duration 0 - tr = otio.opentime.TimeRange( - start_time=otio.opentime.RationalTime(0, 25) - ) + tr = otio.opentime.TimeRange(start_time=otio.opentime.RationalTime(0, 25)) with self.assertRaises(TypeError): tr.extended_by("foo") - assert (tr.duration == otio.opentime.RationalTime()) + assert tr.duration == otio.opentime.RationalTime() def test_end_time(self): # test whole number duration rt_start = otio.opentime.RationalTime(1, 24) rt_dur = otio.opentime.RationalTime(5, 24) tr = otio.opentime.TimeRange(rt_start, rt_dur) - assert (tr.duration == rt_dur) - assert (tr.end_time_exclusive() == rt_start + rt_dur) + assert tr.duration == rt_dur + assert tr.end_time_exclusive() == (rt_start + rt_dur) self.assertEqual( tr.end_time_inclusive(), - rt_start + rt_dur - otio.opentime.RationalTime(1, 24) + rt_start + rt_dur - otio.opentime.RationalTime(1, 24), ) # test non-integer duration value rt_dur = otio.opentime.RationalTime(5.5, 24) tr = otio.opentime.TimeRange(rt_start, rt_dur) - assert (tr.end_time_exclusive() == rt_start + rt_dur) - self.assertEqual( - tr.end_time_inclusive(), - otio.opentime.RationalTime(6, 24) - ) + assert tr.end_time_exclusive() == (rt_start + rt_dur) + self.assertEqual(tr.end_time_inclusive(), otio.opentime.RationalTime(6, 24)) def test_repr(self): tr = otio.opentime.TimeRange( otio.opentime.RationalTime(-1.0, 24.0), - otio.opentime.RationalTime(6.0, 24.0) + otio.opentime.RationalTime(6.0, 24.0), ) self.assertEqual( repr(tr), "otio.opentime.TimeRange(" "start_time=otio.opentime.RationalTime(value=-1, rate=24), " - "duration=otio.opentime.RationalTime(value=6, rate=24))" + "duration=otio.opentime.RationalTime(value=6, rate=24))", ) def test_compare(self): @@ -876,14 +811,14 @@ def test_compare(self): start_time2 = otio.opentime.RationalTime(18, 24) duration2 = otio.opentime.RationalTime(14, 48) tr2 = otio.opentime.TimeRange(start_time2, duration2) - assert (tr1 == tr2) - assert (tr1 != tr2) == False + assert tr1 == tr2 + assert (tr1 != tr2) is False start_time3 = otio.opentime.RationalTime(20, 24) duration3 = otio.opentime.RationalTime(3, 24) tr3 = otio.opentime.TimeRange(start_time3, duration3) - assert (tr1 != tr3) - assert ( tr1 == tr3) == False + assert tr1 != tr3 + assert (tr1 == tr3) is False def test_copy(self): start_time1 = otio.opentime.RationalTime(18, 24) @@ -927,10 +862,10 @@ def test_clamped(self): otio.opentime.RationalTime(7, 24), ) - assert (tr.clamped(test_point_min) == tr.start_time) - assert (tr.clamped(test_point_max) == tr.end_time_inclusive()) + assert tr.clamped(test_point_min) == tr.start_time + assert tr.clamped(test_point_max) == tr.end_time_inclusive() - assert (tr.clamped(other_tr) == tr) + assert tr.clamped(other_tr) == tr def test_overlaps_garbage(self): tstart = otio.opentime.RationalTime(12, 25) @@ -947,24 +882,23 @@ def test_contains(self): with self.assertRaises(TypeError): tr.contains("foo") - assert(tr.contains(tstart)) - assert(tr.contains(tstart+tdur)) == False - assert(tr.contains(tstart-tdur)) == False + assert tr.contains(tstart) + assert tr.contains(tstart + tdur) is False + assert tr.contains(tstart - tdur) is False - assert(tr.contains(tr)) == False + assert tr.contains(tr) is False tr_2 = otio.opentime.TimeRange(tstart - tdur, tdur) - assert(tr.contains(tr_2)) == False - assert(tr_2.contains(tr)) == False + assert tr.contains(tr_2) is False + assert tr_2.contains(tr) is False def test_overlaps_rationaltime(self): tstart = otio.opentime.RationalTime(12, 25) tdur = otio.opentime.RationalTime(3, 25) tr = otio.opentime.TimeRange(tstart, tdur) - assert(tr.overlaps(otio.opentime.RationalTime(13,25))) - assert(tr.overlaps(otio.opentime.RationalTime(1,25))) == False - + assert tr.overlaps(otio.opentime.RationalTime(13, 25)) + assert tr.overlaps(otio.opentime.RationalTime(1, 25)) is False def test_overlaps_timerange(self): tstart = otio.opentime.RationalTime(12, 25) @@ -975,50 +909,49 @@ def test_overlaps_timerange(self): tdur = otio.opentime.RationalTime(3, 25) tr_t = otio.opentime.TimeRange(tstart, tdur) - assert(tr.overlaps(tr_t)) == False + assert tr.overlaps(tr_t) is False tstart = otio.opentime.RationalTime(10, 25) tdur = otio.opentime.RationalTime(3, 25) tr_t = otio.opentime.TimeRange(tstart, tdur) - assert(tr.overlaps(tr_t)) == False - + assert tr.overlaps(tr_t) is False tstart = otio.opentime.RationalTime(13, 25) tdur = otio.opentime.RationalTime(1, 25) tr_t = otio.opentime.TimeRange(tstart, tdur) - assert(tr.overlaps(tr_t)) == False + assert tr.overlaps(tr_t) is False tstart = otio.opentime.RationalTime(2, 25) tdur = otio.opentime.RationalTime(30, 25) tr_t = otio.opentime.TimeRange(tstart, tdur) - assert(tr.overlaps(tr_t)) == False + assert tr.overlaps(tr_t) is False tstart = otio.opentime.RationalTime(2, 50) tdur = otio.opentime.RationalTime(60, 50) tr_t = otio.opentime.TimeRange(tstart, tdur) - assert(tr.overlaps(tr_t)) == False + assert tr.overlaps(tr_t) is False tstart = otio.opentime.RationalTime(2, 50) tdur = otio.opentime.RationalTime(14, 50) tr_t = otio.opentime.TimeRange(tstart, tdur) - assert(tr.overlaps(tr_t)) == False + assert tr.overlaps(tr_t) is False tstart = otio.opentime.RationalTime(-100, 50) tdur = otio.opentime.RationalTime(400, 50) tr_t = otio.opentime.TimeRange(tstart, tdur) - assert(tr.overlaps(tr_t)) == False + assert tr.overlaps(tr_t) is False tstart = otio.opentime.RationalTime(100, 50) tdur = otio.opentime.RationalTime(400, 50) tr_t = otio.opentime.TimeRange(tstart, tdur) - assert(tr.overlaps(tr_t)) == False + assert tr.overlaps(tr_t) is False def test_intersects_timerange(self): tstart = otio.opentime.RationalTime(12, 25) @@ -1029,67 +962,67 @@ def test_intersects_timerange(self): tdur = otio.opentime.RationalTime(3, 25) tr_t = otio.opentime.TimeRange(tstart, tdur) - assert(tr.intersects(tr_t)) == False + assert tr.intersects(tr_t) is False tstart = otio.opentime.RationalTime(10, 25) tdur = otio.opentime.RationalTime(3, 25) tr_t = otio.opentime.TimeRange(tstart, tdur) - assert(tr.intersects(tr_t)) + assert tr.intersects(tr_t) tstart = otio.opentime.RationalTime(10, 25) tdur = otio.opentime.RationalTime(2, 25) tr_t = otio.opentime.TimeRange(tstart, tdur) - assert(tr.intersects(tr_t)) == False + assert tr.intersects(tr_t) is False tstart = otio.opentime.RationalTime(14, 25) tdur = otio.opentime.RationalTime(2, 25) tr_t = otio.opentime.TimeRange(tstart, tdur) - assert(tr.intersects(tr_t)) + assert tr.intersects(tr_t) tstart = otio.opentime.RationalTime(15, 25) tdur = otio.opentime.RationalTime(2, 25) tr_t = otio.opentime.TimeRange(tstart, tdur) - assert(tr.intersects(tr_t)) == False + assert tr.intersects(tr_t) is False tstart = otio.opentime.RationalTime(13, 25) tdur = otio.opentime.RationalTime(1, 25) tr_t = otio.opentime.TimeRange(tstart, tdur) - assert(tr.intersects(tr_t)) + assert tr.intersects(tr_t) tstart = otio.opentime.RationalTime(2, 25) tdur = otio.opentime.RationalTime(30, 25) tr_t = otio.opentime.TimeRange(tstart, tdur) - assert(tr.intersects(tr_t)) + assert tr.intersects(tr_t) tstart = otio.opentime.RationalTime(2, 50) tdur = otio.opentime.RationalTime(60, 50) tr_t = otio.opentime.TimeRange(tstart, tdur) - assert(tr.intersects(tr_t)) + assert tr.intersects(tr_t) tstart = otio.opentime.RationalTime(2, 50) tdur = otio.opentime.RationalTime(14, 50) tr_t = otio.opentime.TimeRange(tstart, tdur) - assert(tr.intersects(tr_t)) == False + assert tr.intersects(tr_t) is False tstart = otio.opentime.RationalTime(-100, 50) tdur = otio.opentime.RationalTime(400, 50) tr_t = otio.opentime.TimeRange(tstart, tdur) - assert(tr.intersects(tr_t)) + assert tr.intersects(tr_t) tstart = otio.opentime.RationalTime(100, 50) tdur = otio.opentime.RationalTime(400, 50) tr_t = otio.opentime.TimeRange(tstart, tdur) - assert(tr.intersects(tr_t)) == False + assert tr.intersects(tr_t) is False def test_before_timerange(self): tstart = otio.opentime.RationalTime(12, 25) @@ -1099,14 +1032,14 @@ def test_before_timerange(self): tstart = otio.opentime.RationalTime(10, 25) tdur = otio.opentime.RationalTime(1.5, 25) tr_t = otio.opentime.TimeRange(tstart, tdur) - assert(tr_t.before(tr)) - assert(tr.before(tr_t)) == False + assert tr_t.before(tr) + assert tr.before(tr_t) is False tdur = otio.opentime.RationalTime(12, 25) tr_t = otio.opentime.TimeRange(tstart, tdur) - assert(tr_t.before(tr)) == False + assert tr_t.before(tr) is False - assert(tr.before(tr)) == False + assert tr.before(tr) is False def test_before_rationaltime(self): tafter = otio.opentime.RationalTime(15, 25) @@ -1114,12 +1047,12 @@ def test_before_rationaltime(self): tdur = otio.opentime.RationalTime(3, 25) tr = otio.opentime.TimeRange(tstart, tdur) - assert(tr.before(tafter)) == False - assert(tr.before(tstart)) == False + assert tr.before(tafter) is False + assert tr.before(tstart) is False tdur = otio.opentime.RationalTime(1.99, 25) tr = otio.opentime.TimeRange(tstart, tdur) - assert(tr.before(tafter)) + assert tr.before(tafter) def test_meets(self): tstart = otio.opentime.RationalTime(12, 25) @@ -1128,14 +1061,14 @@ def test_meets(self): tstart = otio.opentime.RationalTime(15, 25) tr_t = otio.opentime.TimeRange(tstart, tdur) - assert(tr.meets(tr_t)) - assert(tr_t.meets(tr)) == False + assert tr.meets(tr_t) + assert tr_t.meets(tr) is False tstart = otio.opentime.RationalTime(14.99, 25) tdur = otio.opentime.RationalTime(0, 25) tr_t = otio.opentime.TimeRange(tstart, tdur) - assert(tr_t.meets(tr_t)) + assert tr_t.meets(tr_t) def test_begins_timerange(self): tstart = otio.opentime.RationalTime(12, 25) @@ -1144,25 +1077,25 @@ def test_begins_timerange(self): tdur = otio.opentime.RationalTime(5, 25) tr_t = otio.opentime.TimeRange(tstart, tdur) - assert(tr.begins(tr_t)) - assert(tr_t.begins(tr)) == False - assert(tr.begins(tr)) == False + assert tr.begins(tr_t) + assert tr_t.begins(tr) is False + assert tr.begins(tr) is False tdur = otio.opentime.RationalTime(0, 25) tr = otio.opentime.TimeRange(tstart, tdur) - assert(tr.begins(tr_t)) - assert(tr.begins(tr)) == False + assert tr.begins(tr_t) + assert tr.begins(tr) is False tstart = otio.opentime.RationalTime(30, 25) tr_t = otio.opentime.TimeRange(tstart, tdur) - assert(tr.begins(tr_t)) == False + assert tr.begins(tr_t) is False tstart = otio.opentime.RationalTime(13, 25) tr_t = otio.opentime.TimeRange(tstart, tdur) tdur = otio.opentime.RationalTime(3, 25) tstart = otio.opentime.RationalTime(12, 25) tr = otio.opentime.TimeRange(tstart, tdur) - assert(tr_t.begins(tr)) == False + assert tr_t.begins(tr) is False def test_begins_rationaltime(self): tend = otio.opentime.RationalTime(15, 25) @@ -1171,9 +1104,9 @@ def test_begins_rationaltime(self): tdur = otio.opentime.RationalTime(3, 25) tr = otio.opentime.TimeRange(tstart, tdur) - assert(tr.begins(tstart)) - assert(tr.begins(tend)) == False - assert(tr.begins(tbefore)) == False + assert tr.begins(tstart) + assert tr.begins(tend) is False + assert tr.begins(tbefore) is False def test_finishes_timerange(self): tstart = otio.opentime.RationalTime(12, 25) @@ -1183,22 +1116,22 @@ def test_finishes_timerange(self): tdur = otio.opentime.RationalTime(2, 25) tr_t = otio.opentime.TimeRange(tstart, tdur) - assert( tr_t.finishes(tr)) - assert(tr.finishes(tr_t)) == False - assert(tr.finishes(tr)) == False + assert tr_t.finishes(tr) + assert tr.finishes(tr_t) is False + assert tr.finishes(tr) is False tdur = otio.opentime.RationalTime(1, 25) tr_t = otio.opentime.TimeRange(tstart, tdur) - assert(tr_t.finishes(tr)) == False + assert tr_t.finishes(tr) is False tstart = otio.opentime.RationalTime(30, 25) tr_t = otio.opentime.TimeRange(tstart, tdur) - assert(tr_t.finishes(tr)) == False + assert tr_t.finishes(tr) is False tstart = otio.opentime.RationalTime(15, 25) tdur = otio.opentime.RationalTime(0, 25) tr_t = otio.opentime.TimeRange(tstart, tdur) - assert(tr_t.finishes(tr)) + assert tr_t.finishes(tr) def test_finishes_rationaltime(self): tafter = otio.opentime.RationalTime(16, 25) @@ -1207,33 +1140,31 @@ def test_finishes_rationaltime(self): tdur = otio.opentime.RationalTime(3, 25) tr = otio.opentime.TimeRange(tstart, tdur) - assert(tr.finishes(tend)) - assert(tr.finishes(tstart)) == False - assert(tr.finishes(tafter)) == False + assert tr.finishes(tend) + assert tr.finishes(tstart) is False + assert tr.finishes(tafter) is False def test_range_from_start_end_time(self): tstart = otio.opentime.RationalTime(0, 25) tend = otio.opentime.RationalTime(12, 25) tr = otio.opentime.range_from_start_end_time( - start_time=tstart, - end_time_exclusive=tend + start_time=tstart, end_time_exclusive=tend ) - assert (tr.start_time == tstart) - assert (tr.duration == tend) + assert tr.start_time == tstart + assert tr.duration == tend - assert (tr.end_time_exclusive() == tend) + assert tr.end_time_exclusive() == tend self.assertEqual( - tr.end_time_inclusive(), - tend - otio.opentime.RationalTime(1, 25) + tr.end_time_inclusive(), tend - otio.opentime.RationalTime(1, 25) ) self.assertEqual( tr, otio.opentime.range_from_start_end_time( tr.start_time, tr.end_time_exclusive() - ) + ), ) def test_range_from_start_end_time_inclusive(self): @@ -1241,14 +1172,13 @@ def test_range_from_start_end_time_inclusive(self): tend = otio.opentime.RationalTime(12, 25) tr = otio.opentime.range_from_start_end_time_inclusive( - start_time=tstart, - end_time_inclusive=tend + start_time=tstart, end_time_inclusive=tend ) - assert (tr.start_time == tstart) - assert (tr.duration == otio.opentime.RationalTime(13,25)) + assert tr.start_time == tstart + assert tr.duration == otio.opentime.RationalTime(13, 25) - assert (tr.end_time_inclusive() == tend) + assert tr.end_time_inclusive() == tend self.assertEqual( tr.end_time_inclusive(), otio.opentime.RationalTime(12, 25), @@ -1258,26 +1188,23 @@ def test_range_from_start_end_time_inclusive(self): tr, otio.opentime.range_from_start_end_time_inclusive( tr.start_time, tr.end_time_inclusive() - ) + ), ) def test_adjacent_timeranges(self): d1 = 0.3 d2 = 0.4 r1 = otio.opentime.TimeRange( - otio.opentime.RationalTime(0, 1), - otio.opentime.RationalTime(d1, 1) + otio.opentime.RationalTime(0, 1), otio.opentime.RationalTime(d1, 1) ) r2 = otio.opentime.TimeRange( - r1.end_time_exclusive(), - otio.opentime.RationalTime(d2, 1) + r1.end_time_exclusive(), otio.opentime.RationalTime(d2, 1) ) full = otio.opentime.TimeRange( - otio.opentime.RationalTime(0, 1), - otio.opentime.RationalTime(d1 + d2, 1) + otio.opentime.RationalTime(0, 1), otio.opentime.RationalTime(d1 + d2, 1) ) - assert(r1.overlaps(r2)) == False - assert (r1.extended_by(r2) == full) + assert r1.overlaps(r2) is False + assert r1.extended_by(r2) == full def test_distant_timeranges(self): start = 0.1 @@ -1285,42 +1212,41 @@ def test_distant_timeranges(self): gap = 1.7 d2 = 0.4 r1 = otio.opentime.TimeRange( - otio.opentime.RationalTime(start, 1), - otio.opentime.RationalTime(d1, 1) + otio.opentime.RationalTime(start, 1), otio.opentime.RationalTime(d1, 1) ) r2 = otio.opentime.TimeRange( otio.opentime.RationalTime(start + gap + d1, 1), - otio.opentime.RationalTime(d2, 1) + otio.opentime.RationalTime(d2, 1), ) full = otio.opentime.TimeRange( otio.opentime.RationalTime(start, 1), - otio.opentime.RationalTime(d1 + gap + d2, 1) + otio.opentime.RationalTime(d1 + gap + d2, 1), ) - assert (r1.overlaps(r2)) == False - assert (full == r1.extended_by(r2)) - assert (full == r2.extended_by(r1)) + assert r1.overlaps(r2) is False + assert full == r1.extended_by(r2) + assert full == r2.extended_by(r1) def test_to_timecode_mixed_rates(self): timecode = "00:06:56:17" t = otio.opentime.from_timecode(timecode, 24) - assert (timecode == otio.opentime.to_timecode(t)) - assert (timecode == otio.opentime.to_timecode(t,24)) - assert (timecode != otio.opentime.to_timecode(t, 12)) + assert timecode == otio.opentime.to_timecode(t) + assert timecode == otio.opentime.to_timecode(t, 24) + assert timecode != otio.opentime.to_timecode(t, 12) time1 = otio.opentime.RationalTime(24.0, 24.0) time2 = otio.opentime.RationalTime(1.0, 1.0) self.assertEqual( otio.opentime.to_timecode(time1, 24.0), - otio.opentime.to_timecode(time2, 24.0) + otio.opentime.to_timecode(time2, 24.0), ) def test_to_frames_mixed_rates(self): frame = 100 t = otio.opentime.from_frames(frame, 24) - assert (frame == otio.opentime.to_frames(t)) - assert (frame == otio.opentime.to_frames(t, 24)) - assert (frame != otio.opentime.to_frames(t, 12)) + assert frame == otio.opentime.to_frames(t) + assert frame == otio.opentime.to_frames(t, 24) + assert frame != otio.opentime.to_frames(t, 12) -if __name__ == '__main__': +if __name__ == "__main__": unittest.main()