Docs - Sphinx Indent Errors in Rest of API Reference (#2069)

* Docs - Sphinx Indent Errors in Rest of API Reference

* Fix Spaces in Docs - Sphinx Indent Errors in Rest of API Ref

* Fix2 Spaces in Docs - Sphinx Indent Errors in Rest of API Ref

---------

Co-authored-by: above3 <anthony_bove@apple.com>

Author: tonybove-apple

coremltools/converters/mil/input_types.py

@@ -33,22 +33,21 @@ def __init__(
         Parameters
         ----------
         class_labels: str / list of int / list of str
-            If a ``list`` is provided, the ``list`` maps the index of the output of a
-            neural network to labels in a classifier.
-
-            If a ``str`` is provided, the ``str`` points to a file which maps the index
-            to labels in a classifier.
+            * If a ``list`` is provided, the ``list`` maps the index of the output of a
+              neural network to labels in a classifier.
+            * If a ``str`` is provided, the ``str`` points to a file which maps the index
+              to labels in a classifier.
 
         predicted_feature_name: str
             Name of the output feature for the class labels exposed in the
             Core ML neural network classifier. Default: ``'classLabel'``.
 
         predicted_probabilities_output: str
-            If provided, then this is the name of the neural network blob which
-            generates the probabilities for each class label (typically the output
-            of a softmax layer).
+            * If provided, then this is the name of the neural network blob which
+              generates the probabilities for each class label (typically the output
+              of a softmax layer).
+            * If not provided, then the last output layer is assumed.
 
-            If not provided, then the last output layer is assumed.
         """
         self.class_labels = class_labels
         self.predicted_feature_name = predicted_feature_name
@@ -67,8 +66,8 @@ def __init__(self, name=None, shape=None, dtype=None):
 
         shape: list, tuple, Shape object, EnumeratedShapes object, or None
             The shape(s) that are valid for this input.
-
             If set to ``None``, the shape will be inferred from the model itself.
+
         """
 
         self.name = name
@@ -172,15 +171,16 @@ def __init__(self, name=None, shape=None, dtype=None, default_value=None):
             The ``name`` is required except for a TensorFlow model in which there is
             exactly one input Placeholder.
 
-        shape: (1) list of positive int or RangeDim, or (2) EnumeratedShapes
-            The shape of the input.
+        shape: The shape of the input
+            - List of positive int or :py:class:`RangeDim`, or
+            - :py:class:`EnumeratedShapes`
 
             For TensorFlow:
-              * The ``shape`` is optional. If omitted, the shape is inferred from
-                TensorFlow graph's Placeholder shape.
+               * The ``shape`` is optional. If omitted, the shape is inferred from
+                 TensorFlow graph's Placeholder shape.
 
             For PyTorch:
-              * The ``shape`` is required.
+               * The ``shape`` is required.
 
         dtype: np.generic or mil.type type
             For example, ``np.int32`` or ``coremltools.converters.mil.mil.types.fp32``
@@ -194,7 +194,7 @@ def __init__(self, name=None, shape=None, dtype=None, default_value=None):
                  elements are required to have the same value.
 
               * The ``default_value`` may not be specified if ``shape`` is
-                ``EnumeratedShapes``.
+                :py:class:`EnumeratedShapes`.
 
         Examples
         --------
@@ -339,7 +339,7 @@ def __str__(self):
 class Shape:
     def __init__(self, shape, default=None):
         """
-        The basic shape class to be set in InputType.
+        The basic shape class to be set in :py:class:`InputType`.
 
         Parameters
         ----------
@@ -350,7 +350,7 @@ def __init__(self, shape, default=None):
             The default shape that is used for initiating the model, and set in
             the metadata of the model file.
 
-            If None, then ``shape`` is used.
+            If ``None``, then ``shape`` is used.
         """
         from coremltools.converters.mil.mil import get_new_symbol
 
@@ -430,35 +430,36 @@ def __init__(self, shapes, default=None):
 
         Parameters
         ----------
-        shapes: list of Shape objects, or Shape-compatible lists.
-            The valid shapes of the inputs.
+        shapes: list of Shape objects, or Shape-compatible lists
+            * The valid shapes of the inputs.
+            * If input provided is not a :py:class:`Shape` object,
+              but can be converted to a :py:class:`Shape`,
+              the :py:class:`Shape` object would be stored in ``shapes`` instead.
 
-            If input provided is not a Shape object, but can be converted to a Shape,
-            the Shape object would be stored in ``shapes`` instead.
 
         default: tuple of int or None
-            The default shape that is used for initiating the model, and set in
-            the metadata of the model file.
+            * The default shape that is used for initiating the model, and set in
+              the metadata of the model file.
+            * If ``None``, then the first element in ``shapes`` is used.
 
-            If None, then the first element in ``shapes`` is used.
 
         Examples
         --------
         .. sourcecode:: python
 
-        sample_shape = ct.EnumeratedShapes(
-            shapes=[
-                (2, 4, 64, 64),
-                (2, 4, 48, 48),
-                (2, 4, 32, 32)
-            ],
-            default=(2, 4, 64, 64)
-        )
-
-        my_core_ml_model = ct.convert(
-            my_model,
-            inputs=[ct.TensorType(name="sample", shape=sample_shape)],
-        )
+            sample_shape = ct.EnumeratedShapes(
+               shapes=[
+                    (2, 4, 64, 64),
+                    (2, 4, 48, 48),
+                    (2, 4, 32, 32)
+                ],
+                default=(2, 4, 64, 64)
+            )
+
+            my_core_ml_model = ct.convert(
+                my_model,
+                inputs=[ct.TensorType(name="sample", shape=sample_shape)],
+            )
         """
 
         # lazy import to avoid circular import

coremltools/converters/mil/mil/ops/defs/iOS15/image_resizing.py

@@ -644,9 +644,7 @@ class affine(Operation):
     the coordinates ``x’`` and ``y’`` with the following equation, and then computing the
     value at the coordinate ``(x’,y’)`` in the input image using either bilinear or
     nearest neighbor interpolation. If the ``(x’, y’)`` point falls outside the input
-    image, then padding information is used to compute the value.
-
-    ::
+    image, then padding information is used to compute the value::
 
         x’ = a0 * x + a1 * y + a2
         y’ = b0 * x + b1 * y + b2
@@ -655,45 +653,41 @@ class affine(Operation):
     Parameters
     ----------
     x: tensor<[B, C, H1, W1], T>
-        * Must be rank ``4``.
+       * Must be rank ``4``.
     transform_matrix: tensor<[D, 6], T>
-        * Must be rank ``2``.
-        * ``D`` can be either ``B`` or 1.
-            * If ``D == B``, there is a separate transform matrix for each batch.
-            * If ``D == 1``, the same matrix is used for all input batches.
-            * For each batch: ``[a0, a1, a2, b0, b1, b2]``.
+       * Must be rank ``2``.
+       * ``D`` can be either ``B`` or 1.
+          * If ``D == B``, there is a separate transform matrix for each batch.
+          * If ``D == 1``, the same matrix is used for all input batches.
+          * For each batch: ``[a0, a1, a2, b0, b1, b2]``.
     output_height: const<i32>
-        * Target output height
+       * Target output height
     output_width: const<i32>
-        * Target output width
+       * Target output width
     sampling_mode: const<str>
-        * Allowed values: ``"bilinear"``
+       * Allowed values: ``"bilinear"``
     padding_mode: const<str>
-        * Allowed values: ``"constant"``.
-        * Note that the following example is 1D case for brevity.
-          The op supports only 2D image input.
-        * If ``padding_mode == "constant"``:
-            * The input image is assumed to be padded with the padding_value.
-            * For example, ``|1, 2, 3| -> |0, 0, 0, 1, 2, 3, 0, 0, 0|``.
+       * Allowed values: ``"constant"``.
+       * Note that the following example is 1D case for brevity. The op supports only 2D image input.
+       * If ``padding_mode == "constant"``:
+          * The input image is assumed to be padded with the padding_value.
+          * For example, ``|1, 2, 3| -> |0, 0, 0, 1, 2, 3, 0, 0, 0|``.
     padding_value: const<T>
-        * Currently non-zero values are not supported.
-        * To be used only when ``padding_mode == "constant"``, ignored in other cases.
+       * Currently non-zero values are not supported.
+       * To be used only when ``padding_mode == "constant"``, ignored in other cases.
     coordinates_mode: const<str>
-        * Allowed values: ``"normalized_minus_one_to_one"``
-        * If ``coordinates_mode == "normalized_minus_one_to_one"``, in-image values are ``[-1, 1]``.
-        * For example, if ``coordinates_mode == "normalized_minus_one_to_one"``,
-          the in range values are ``[-1, 1]``. That is:
-            * ``(-1, -1)``, i.e. ``(w=-1, h=-1)``, corresponds to the top-left pixel.
-            * ``(1, -1)``, i.e. ``(w=1, h=-1)``, corresponds to the top-right pixel.
-            * ``(-1, 1)``, i.e. ``(w=-1, h=1)``, corresponds to the bottom-left pixel.
-            * ``(1, 1)``, i.e. ``(w=1, h=1)``, corresponds to the bottom-right pixel.
+       * Allowed values: ``"normalized_minus_one_to_one"``.
+       * If ``coordinates_mode == "normalized_minus_one_to_one"``, in-image values are ``[-1, 1]``.
+       * For example, if ``coordinates_mode == "normalized_minus_one_to_one"``, the in-range values are ``[-1, 1]``. That is:
+          * ``(-1, -1)``, i.e. ``(w=-1, h=-1)``, corresponds to the top-left pixel.
+          * ``(1, -1)``, i.e. ``(w=1, h=-1)``, corresponds to the top-right pixel.
+          * ``(-1, 1)``, i.e. ``(w=-1, h=1)``, corresponds to the bottom-left pixel.
+          * ``(1, 1)``, i.e. ``(w=1, h=1)``, corresponds to the bottom-right pixel.
     align_corners: const<bool>
-        * Currently ``align_corners=False`` is not supported.
-        * To be used only when ``coordinates_mode != unnormalized``, ignored otherwise.
-        * if ``align_corners == True``, the extrema coordinates correspond
-          to the center of the first and last corner pixels.
-        * if ``align_corners == False``, the extrema coordinates correspond
-          to the edge of the first and last corner pixels.
+       * Currently ``align_corners=False`` is not supported.
+       * To be used only when ``coordinates_mode != unnormalized``, ignored otherwise.
+       * If ``align_corners == True``, the extrema coordinates correspond to the center of the first and last corner pixels.
+       * If ``align_corners == False``, the extrema coordinates correspond to the edge of the first and last corner pixels.
 
     Returns
     -------
@@ -799,20 +793,20 @@ class resample(Operation):
         * Note that the following example is 1D case for brevity.
           The op supports only 2D image input.
         * If ``padding_mode == "constant"``:
-            * The input image is assumed to be padded with the ``padding_value``.
-            * For example: ``|1, 2, 3| -> |0, 0, 0, 1, 2, 3, 0, 0, 0|``
+           * The input image is assumed to be padded with the ``padding_value``.
+           * For example: ``|1, 2, 3| -> |0, 0, 0, 1, 2, 3, 0, 0, 0|``
         * if ``padding_mode == "border"``:
-            * The input image is assumed to be padded with the values replicated
-              from the values at the edge. This is also referred to as the
-              "clamped" or "replication" mode, since the padded values are
-              clamped to the border values.
-            * For example: ``|1, 2, 3| -> |1, 1, 1, 1, 2, 3, 3, 3, 3|``
+           * The input image is assumed to be padded with the values replicated
+             from the values at the edge. This is also referred to as the
+             "clamped" or "replication" mode, since the padded values are
+             clamped to the border values.
+           * For example: ``|1, 2, 3| -> |1, 1, 1, 1, 2, 3, 3, 3, 3|``
         * If ``padding_mode == "reflection"``:
-            * The border values are reflected, *not* including the values at the edge/border.
-            * For example: ``|1, 2, 3| -> |2, 3, 2, 1, 2, 3, 2, 1, 2|``
+           * The border values are reflected, *not* including the values at the edge/border.
+           * For example: ``|1, 2, 3| -> |2, 3, 2, 1, 2, 3, 2, 1, 2|``
         * If ``padding_mode == "symmetric"``:
-            * Values are reflected, including the border/edge values.
-            * For example: ``|1, 2, 3| -> |3, 2, 1 , 1, 2, 3, 3, 2, 1|``
+           * Values are reflected, including the border/edge values.
+           * For example: ``|1, 2, 3| -> |3, 2, 1 , 1, 2, 3, 3, 2, 1|``
     padding_value: const<T>
         * To be used only when ``padding_mode == "constant"``, ignored in other cases.
     coordinates_mode: const<str>
@@ -825,17 +819,14 @@ class resample(Operation):
           the in-image values are ``[-1, 1]``.
         * If ``coordinates_mode == "normalized_zero_to_one"``,
           in-image values are ``[0, 1]``.
-        * For example, if ``coordinates_mode == "normalized_minus_one_to_one"``,
-          the in range values are [-1, 1]. That is:
-            * ``(-1, -1)``, i.e. ``(w=-1, h=-1)``, corresponds to the top-left pixel.
-            * ``(1, -1)``, i.e. ``(w=1, h=-1)``, corresponds to the top-right pixel.
-            * ``(-1, 1)``, i.e. ``(w=-1, h=1)``, corresponds to the bottom-left pixel.
-            * ``(1, 1)``, i.e. ``(w=1, h=1)``, corresponds to the bottom-right pixel.
+        * For example, if ``coordinates_mode == "normalized_minus_one_to_one"``, the in range values are [-1, 1]. That is:
+           * ``(-1, -1)``, i.e. ``(w=-1, h=-1)``, corresponds to the top-left pixel.
+           * ``(1, -1)``, i.e. ``(w=1, h=-1)``, corresponds to the top-right pixel.
+           * ``(-1, 1)``, i.e. ``(w=-1, h=1)``, corresponds to the bottom-left pixel.
+           * ``(1, 1)``, i.e. ``(w=1, h=1)``, corresponds to the bottom-right pixel.
     align_corners: const<bool>
-        * If ``align_corners == True``, the extrema coordinates correspond
-          to the center of the first and last corner pixels.
-        * If ``align_corners == False``, the extrema coordinates correspond
-          to the edge of the first and last corner pixels.
+        * If ``align_corners == True``, the extrema coordinates correspond to the center of the first and last corner pixels.
+        * If ``align_corners == False``, the extrema coordinates correspond to the edge of the first and last corner pixels.
 
     Returns
     -------

coremltools/converters/mil/mil/ops/defs/iOS16/constexpr_ops.py

@@ -22,8 +22,10 @@ class constexpr_affine_dequantize(Operation):
     The quantized data is stored in the parameter ``quantized_data``.
     The other parameters -- ``scale``, ``zero_point``, and ``axis`` -- describe how
     unquantized values can be extracted from it, using the equation for affine/linear quantization:
-    ::
-                unquantized_data = scale * (quantized_data - zero_point)
+
+    .. sourcecode:: python
+
+        unquantized_data = scale * (quantized_data - zero_point)
 
     Although all of the parameters of this op are constants, this op is not constant folded
     to a single const op at the time of model serialization. The unquantized output will
@@ -38,15 +40,15 @@ class constexpr_affine_dequantize(Operation):
  	   * ``zero_point`` follows similar broadcasting rules and size constraints as ``scale``.
 
     scale: const tensor<DstT, [0..1]> (Required)
-       * ``scale`` can be either a scalar or a vector. If ``scale`` is a vector,
-         for implementation it is broadcast to the following shape:
-           * The rank of ``scale`` becomes the same as the rank of ``quantized_data``.
-           * The constraint: ``size(scale-vector) == quantized_data.shape[axis]``.
-           * For ``i == axis``, ``scale.shape[i] == quantized_data.shape[i]``.
-           * For ``i != axis``, ``scale.shape == 1``.
-         For example, assume ``quantized_data.shape = (2, 3, 4, 5)`` and ``axis = 1``.
-         If ``scale`` is a vector, then ``scale.size`` needs to be equal to
-         ``quantized_data.shape[axis] i.e = 3``, which would be broadcast to ``(1, 3, 1, 1)``.
+       * ``scale`` can be either a scalar or a vector.
+       * If ``scale`` is a vector, for implementation it is broadcast to the following shape:
+          * The rank of ``scale`` becomes the same as the rank of ``quantized_data``.
+          * The constraint: ``size(scale-vector) == quantized_data.shape[axis]``.
+          * For ``i == axis``, ``scale.shape[i] == quantized_data.shape[i]``.
+          * For ``i != axis``, ``scale.shape == 1``.
+            For example, assume ``quantized_data.shape = (2, 3, 4, 5)`` and ``axis = 1``.
+            If ``scale`` is a vector, then ``scale.size`` needs to be equal to
+            ``quantized_data.shape[axis] i.e = 3``, which would be broadcast to ``(1, 3, 1, 1)``.
 
     axis: const tensor<int32, []> (Required)
 
@@ -136,8 +138,10 @@ def rank_promoted_to_same_as_quantized_data(param):
 class constexpr_cast(Operation):
     """
     A compile-time operation that returns a constant output value upon casting its constant input.
-    ::
-                Expression: output = constexpr_cast(source_val, output_dtype="fp32")
+
+    .. sourcecode:: python
+
+        Expression: output = constexpr_cast(source_val, output_dtype="fp32")
 
     Parameters
     ----------
@@ -205,7 +209,9 @@ class constexpr_lut_to_dense(Operation):
     bits of the same index are filled in the LSBs of the next byte.
 
     For example:
-    ::
+
+    .. sourcecode:: python
+
         if n_bits = 2, shape = (5,) => M = 2 bytes
 
                     MSB             LSB
@@ -301,15 +307,18 @@ class constexpr_sparse_to_dense(Operation):
     moving up to the most significant bit.
 
     For example:
-    ::
-        shape = (5,) => M = 1 bytes
 
+    .. sourcecode:: python
+
+        shape = (5,) => M = 1 bytes
+        
                    MSB                  LSB
                     |                    |
         mask    =  |x  x  x  0  1  1  0  0 |      <== packed elements
                    |--|--|--|i4|i3|i2|i1|i0|      <== tagged element ids
                    |      byte 0           |      <== tagged bytes
 
+
     Returns
     -------
     const tensor<T, [...]>

coremltools/converters/mil/mil/ops/defs/iOS17/image_resizing.py

@@ -263,8 +263,7 @@ class resize(Operation):
         * Available mode: ``LINEAR``, ``NEAREST_NEIGHBOR``.
 
     sampling_mode: const<str> (Optional, default="DEFAULT")
-        * Available mode: ``DEFAULT``, ``STRICT_ALIGN_CORNERS``, ``ALIGN_CORNERS``,
-        ``OFFSET_CORNERS``, ``UNALIGN_CORNERS``.
+        * Available mode: ``DEFAULT``, ``STRICT_ALIGN_CORNERS``, ``ALIGN_CORNERS``, ``OFFSET_CORNERS``, ``UNALIGN_CORNERS``.
         * For details about different sampling modes, see iOS 15 :py:class:`~.iOS15.image_resizing.resize_bilinear`.
 
     Returns