add iosys_repr and set default __repr__ to short form

Author: murrayrm

control/frdata.py

@@ -391,10 +391,37 @@ def __str__(self):
         return '\n'.join(outstr)
 
     def __repr__(self):
-        """Loadable string representation,
+        return self.iosys_repr(format=self.repr_format)
+
+    def iosys_repr(self, format='loadable'):
+        """Return representation of a transfer function.
+
+        Parameters
+        ----------
+        format : str
+            Format to use in creating the representation:
+
+              * 'iosys' : <FrequencyResponseData:sysname:[inputs]->[outputs]
+              * 'loadable' : FrequencyResponseData(response, omega[, dt[, ...]])
+
+        Returns
+        -------
+        str
+            String representing the transfer function.
+
+        Notes
+        -----
+        By default, the representation for a frequency response is set to
+        'iosys'.  Set config.defaults['iosys.repr_format'] to change for all
+        I/O systems or set the `repr_format` attribute for a single system.
 
-        limited for number of data points.
         """
+        if format == 'iosys':
+            return super().__repr__()
+        elif format != 'loadable':
+            raise ValueError(f"unknown format '{format}'")
+
+        # Loadable format
         out = "FrequencyResponseData(\n{d},\n{w}{smooth}".format(
             d=repr(self.fresp), w=repr(self.omega),
             smooth=(self.ifunc and ", smooth=True") or "")

control/iosys.py

@@ -31,6 +31,7 @@
     'iosys.indexed_system_name_suffix': '$indexed',
     'iosys.converted_system_name_prefix': '',
     'iosys.converted_system_name_suffix': '$converted',
+    'iosys.repr_format': 'iosys',
 }
 
 
@@ -189,6 +190,8 @@ def __init__(
         # Process timebase: if not given use default, but allow None as value
         self.dt = _process_dt_keyword(kwargs)
 
+        self._repr_format = kwargs.pop('repr_format', None)
+
         # Make sure there were no other keywords
         if kwargs:
             raise TypeError("unrecognized keywords: ", str(kwargs))
@@ -247,6 +250,20 @@ def __repr__(self):
         return f'<{self.__class__.__name__}:{self.name}:' + \
             f'{list(self.input_labels)}->{list(self.output_labels)}>'
 
+    def iosys_repr(self, format=None):
+        raise NotImplementedError(
+            f"`iosys_repr` is not implemented for {self.__class__}")
+
+    @property
+    def repr_format(self):
+        """Set the string representation format ('iosys' or 'loadable')."""
+        return self._repr_format if self._repr_format is not None \
+            else config.defaults['iosys.repr_format']
+
+    @repr_format.setter
+    def repr_format(self, value):
+        self._repr_format = value
+
     def __str__(self):
         """String representation of an input/output object"""
         str = f"<{self.__class__.__name__}>: {self.name}\n"

control/statesp.py

@@ -428,9 +428,38 @@ def __str__(self):
             string += f"\ndt = {self.dt}\n"
         return string
 
-    # represent to implement a re-loadable version
     def __repr__(self):
-        """Print state-space system in loadable form."""
+        return self.iosys_repr(format=self.repr_format)
+
+    def iosys_repr(self, format='loadable'):
+        """Return representation of a state sapce system.
+
+        Parameters
+        ----------
+        format : str
+            Format to use in creating the representation:
+
+              * 'iosys' : <TransferFunction:sysname:[inputs]->[outputs]
+              * 'loadable' : StateSpace(A, B, C, D[, dt[, ...]])
+
+        Returns
+        -------
+        str
+            String representing the transfer function.
+
+        Notes
+        -----
+        By default, the representation for a state space system is set to
+        'iosys'.  Set config.defaults['iosys.repr_format'] to change for all
+        I/O systems or set the `repr_format` attribute for a single system.
+
+        """
+        if format == 'iosys':
+            return super().__repr__()
+        elif format != 'loadable':
+            raise ValueError(f"unknown format '{format}'")
+
+        # Loadable format
         out = "StateSpace(\n{A},\n{B},\n{C},\n{D}".format(
             A=self.A.__repr__(), B=self.B.__repr__(),
             C=self.C.__repr__(), D=self.D.__repr__())

control/tests/frd_test.py

@@ -474,14 +474,14 @@ def test_repr_str(self):
         sysm = ct.frd(
             np.matmul(array([[1], [2]]), sys0.fresp), sys0.omega, name='sysm')
 
-        assert repr(sys0) == ref0
-        assert repr(sys1) == ref1
+        assert sys0.iosys_repr(format='loadable') == ref0
+        assert sys1.iosys_repr(format='loadable') == ref1
 
-        sys0r = eval(repr(sys0))
+        sys0r = eval(sys0.iosys_repr(format='loadable'))
         np.testing.assert_array_almost_equal(sys0r.fresp, sys0.fresp)
         np.testing.assert_array_almost_equal(sys0r.omega, sys0.omega)
 
-        sys1r = eval(repr(sys1))
+        sys1r = eval(sys1.iosys_repr(format='loadable'))
         np.testing.assert_array_almost_equal(sys1r.fresp, sys1.fresp)
         np.testing.assert_array_almost_equal(sys1r.omega, sys1.omega)
         assert(sys1.ifunc is not None)

control/tests/iosys_test.py

@@ -2314,7 +2314,8 @@ def test_signal_indexing():
         'long_state_1', 'long_state_2', 'long_state_3']},
      r"[\n]name='.*', states=\[.*\],[\n]outputs=3, inputs=2\)", r"dt"),
 ])
-def test_system_repr(fcn, spec, expected, missing):
+@pytest.mark.parametrize("format", ['iosys', 'loadable'])
+def test_loadable_system_repr(fcn, spec, expected, missing, format):
     spec['outputs'] = spec.get('outputs', 3)
     spec['inputs'] = spec.get('inputs', 2)
     if fcn is ct.ss:
@@ -2327,11 +2328,31 @@ def test_system_repr(fcn, spec, expected, missing):
             sys = fcn(sys, omega, name=spec.get('name'))
         case ct.tf:
             sys = fcn(sys, name=spec.get('name'))
-
     assert sys.shape == (sys.noutputs, sys.ninputs)
 
+    # Construct the 'iosys' format
+    iosys_expected = f"<{sys.__class__.__name__}:{sys.name}:" \
+        f"{sys.input_labels}->{sys.output_labels}>"
+
+    # Make sure the default format is OK
+    out = repr(sys)
+    if ct.config.defaults['iosys.repr_format'] == 'iosys':
+        assert out == iosys_expected
+    else:
+        assert re.search(expected, out) != None
+        
+    # Now set the format to the given type and make sure things look right
+    sys.repr_format = format
     out = repr(sys)
-    assert re.search(expected, out) != None
+    if format == 'loadable':
+        assert re.search(expected, out) != None
 
-    if missing is not None:
-        assert re.search(missing, out) is None
+        if missing is not None:
+            assert re.search(missing, out) is None
+
+        # Make sure we can change the default format back to 'iosys'
+        sys.repr_format = None
+
+    # Test 'iosys', either set explicitly or via config.defaults
+    out = repr(sys)
+    assert out == iosys_expected

control/tests/statesp_test.py

@@ -748,12 +748,12 @@ def test_repr(self, sys322):
              "array([[-2.,  4.],",
              "       [ 0.,  1.]]){dt},",
              "name='sys322', states=3, outputs=2, inputs=2)"])
-        assert repr(sys322) == ref322.format(dt='')
+        assert sys322.iosys_repr(format='loadable') == ref322.format(dt='')
         sysd = StateSpace(sys322.A, sys322.B,
                           sys322.C, sys322.D, 0.4)
-        assert repr(sysd), ref322.format(dt="\ndt=0.4")
+        assert sysd.iosys_repr(format='loadable'), ref322.format(dt="\ndt=0.4")
         array = np.array  # noqa
-        sysd2 = eval(repr(sysd))
+        sysd2 = eval(sysd.iosys_repr(format='loadable'))
         np.testing.assert_allclose(sysd.A, sysd2.A)
         np.testing.assert_allclose(sysd.B, sysd2.B)
         np.testing.assert_allclose(sysd.C, sysd2.C)

control/tests/xferfcn_test.py

@@ -1121,15 +1121,16 @@ def test_latex_repr(self):
           "dt=0.5,\n"
           "outputs=2, inputs=2)"),
          ])
-    def test_repr(self, Hargs, ref):
+    def test_loadable_repr(self, Hargs, ref):
         """Test __repr__ printout."""
         H = TransferFunction(*Hargs)
 
-        assert repr(H) == ref
+        rep = H.iosys_repr(format='loadable')
+        assert rep == ref
 
         # and reading back
         array = np.array  # noqa
-        H2 = eval(H.__repr__())
+        H2 = eval(rep)
         for p in range(len(H.num)):
             for m in range(len(H.num[0])):
                 np.testing.assert_array_almost_equal(

control/xferfcn.py

@@ -460,9 +460,38 @@ def __str__(self, var=None):
 
         return outstr
 
-    # represent to implement a re-loadable version
     def __repr__(self):
-        """Print transfer function in loadable form."""
+        return self.iosys_repr(format=self.repr_format)
+
+    def iosys_repr(self, format='loadable'):
+        """Return representation of a transfer function.
+
+        Parameters
+        ----------
+        format : str
+            Format to use in creating the representation:
+
+              * 'iosys' : <TransferFunction:sysname:[inputs]->[outputs]
+              * 'loadable' : TransferFunction(num, den[, dt[, ...]])
+
+        Returns
+        -------
+        str
+            String representing the transfer function.
+
+        Notes
+        -----
+        By default, the representation for a transfer function is set to
+        'iosys'.  Set config.defaults['iosys.repr_format'] to change for all
+        I/O systems or set the `repr_format` attribute for a single system.
+
+        """
+        if format == 'iosys':
+            return super().__repr__()
+        elif format != 'loadable':
+            raise ValueError(f"unknown format '{format}'")
+
+        # Loadable format
         if self.issiso():
             out = "TransferFunction(\n{num},\n{den}".format(
                 num=self._num[0, 0].__repr__(), den=self._den[0, 0].__repr__())