Updated constructors and reprs to better match expectations

Signed-off-by: Eric Reinecke <ereinecke@netflix.com>

Author: reinecke

src/py-opentimelineio/opentimelineio-bindings/otio_serializableObjects.cpp

@@ -803,13 +803,11 @@ static void define_stream_effects(py::module m) {
         "Use this to select a stereo view, specific audio channels, etc. "
         "The item will expose these streams downstream with the same naming.")
         .def(py::init([](std::string name,
-                         std::string effect_name,
                          std::vector<std::string> output_streams,
                          py::object metadata) {
-                return new StreamSelector(name, effect_name, output_streams,
+                return new StreamSelector(name, "StreamSelector", output_streams,
                                          py_to_any_dictionary(metadata)); }),
              py::arg_v("name"_a = std::string()),
-             "effect_name"_a = std::string(),
              "output_streams"_a = std::vector<std::string>(),
              py::arg_v("metadata"_a = py::none()))
         .def_property("output_streams",
@@ -827,13 +825,11 @@ static void define_stream_effects(py::module m) {
         "well-known StreamInfo.Identifier value -- for example, to expose the "
         "left eye of a stereo source as the conventional monocular stream.")
         .def(py::init([](std::string name,
-                         std::string effect_name,
                          StreamMapper::StreamMap stream_map,
                          py::object metadata) {
-                return new StreamMapper(name, effect_name, stream_map,
+                return new StreamMapper(name, "StreamMapper", stream_map,
                                         py_to_any_dictionary(metadata)); }),
              py::arg_v("name"_a = std::string()),
-             "effect_name"_a = std::string(),
              "stream_map"_a = StreamMapper::StreamMap(),
              py::arg_v("metadata"_a = py::none()))
         .def_property("stream_map",

src/py-opentimelineio/opentimelineio/schema/stream_mapper.py

@@ -7,9 +7,25 @@
 
 @add_method(_otio.StreamMapper)
 def __str__(self):
-    return "StreamMapper({})".format(str(self.name))
+    return (
+        "StreamMapper("
+        "{}, "
+        "{}"
+        ")".format(
+            str(self.name),
+            str(self.stream_map),
+        )
+    )
 
 
 @add_method(_otio.StreamMapper)
 def __repr__(self):
-    return "otio.schema.StreamMapper(name={})".format(repr(self.name))
+    return (
+        "otio.schema.StreamMapper("
+        "name={}, "
+        "stream_map={}"
+        ")".format(
+            repr(self.name),
+            repr(self.stream_map),
+        )
+    )

src/py-opentimelineio/opentimelineio/schema/stream_selector.py

@@ -10,11 +10,9 @@ def __str__(self):
     return (
         "StreamSelector("
         "{}, "
-        "{}, "
         "{}"
         ")".format(
             str(self.name),
-            str(self.effect_name),
             str(self.output_streams),
         )
     )
@@ -25,11 +23,9 @@ def __repr__(self):
     return (
         "otio.schema.StreamSelector("
         "name={}, "
-        "effect_name={}, "
         "output_streams={}"
         ")".format(
             repr(self.name),
-            repr(self.effect_name),
             repr(self.output_streams),
         )
     )

tests/test_stream_mapping.py

@@ -159,13 +159,12 @@ class TestStreamSelector(unittest.TestCase):
     def test_create_default(self):
         sel = otio.schema.StreamSelector()
         self.assertEqual(sel.name, "")
-        self.assertEqual(sel.effect_name, "")
+        self.assertEqual(sel.effect_name, "StreamSelector")
         self.assertEqual(sel.output_streams, [])
 
     def test_create_with_streams(self):
         sel = otio.schema.StreamSelector(
             name="stereo_select",
-            effect_name="StreamSelector",
             output_streams=[
                 StreamInfo.Identifier.stereo_left,
                 StreamInfo.Identifier.stereo_right,
@@ -420,7 +419,7 @@ def test_use_as_clip_effect(self):
         self.assertEqual(len(restored.effects), 1)
         mapper = restored.effects[0]
         self.assertIsInstance(mapper, otio.schema.StreamMapper)
-        self.assertEqual(mapper.name, "A very bad stereo downmix")
+        self.assertEqual(mapper.name, "a very bad stereo downmix")
         self.assertEqual(
             mapper.stream_map[StreamInfo.Identifier.stereo_left],
             StreamInfo.Identifier.surround_left_front