[EH] strict sphinx (#34062)

* strict sphinx

* remove until mgmt packages arent checked

* checkpointstoretable strcit_sphinx

Author: l0lawrence

sdk/eventhub/azure-eventhub-checkpointstoretable/README.md

@@ -5,12 +5,13 @@
 Azure EventHubs Checkpoint Store is used for storing checkpoints while processing events from Azure Event Hubs.
 This Checkpoint Store package works as a plug-in package to `EventHubConsumerClient`. It uses Azure Tables as the persistent store for maintaining checkpoints and partition ownership information.
 
+
+# Getting started
+
 ## _Disclaimer_
 
 _Azure SDK Python packages support for Python 2.7 is ending 01 January 2022. For more information and questions, please refer to https://github.com/Azure/azure-sdk-for-python/issues/20691_
 
-# Getting started
-
 ### Prerequisites
 
 - Python2.7, Python 3.6 or later.

sdk/eventhub/azure-eventhub-checkpointstoretable/azure/eventhub/extensions/checkpointstoretable/_tablestoragecs.py

@@ -226,16 +226,16 @@ def list_ownership(
          relative to the Event Hubs namespace that contains it.
         :param str consumer_group: The name of the consumer group the ownerships are associated with.
         :rtype: Iterable[Dict[str, Any]], Iterable of dictionaries containing partition ownership information:
-                - `fully_qualified_namespace` (str): The fully qualified namespace that the Event Hub belongs to.
-                  The format is like "<namespace>.servicebus.windows.net".
-                - `eventhub_name` (str): The name of the specific Event Hub the checkpoint is associated with,
-                  relative to the Event Hubs namespace that contains it.
-                - `consumer_group` (str): The name of the consumer group the ownership are associated with.
-                - `partition_id` (str): The partition ID which the checkpoint is created for.
-                - `owner_id` (str): A UUID representing the current owner of this partition.
-                - `last_modified_time` (float): The last time this ownership was claimed.
-                - `etag` (str): The Etag value for the last time this ownership was modified. Optional depending
-                  on storage implementation.
+         - `fully_qualified_namespace` (str): The fully qualified namespace that the Event Hub belongs to.
+         The format is like "<namespace>.servicebus.windows.net".
+         - `eventhub_name` (str): The name of the specific Event Hub the checkpoint is associated with,
+         relative to the Event Hubs namespace that contains it.
+         - `consumer_group` (str): The name of the consumer group the ownership are associated with.
+         - `partition_id` (str): The partition ID which the checkpoint is created for.
+         - `owner_id` (str): A UUID representing the current owner of this partition.
+         - `last_modified_time` (float): The last time this ownership was claimed.
+         - `etag` (str): The Etag value for the last time this ownership was modified. Optional depending
+         on storage implementation.
         """
         try:
             partition_key = "{} {} {} Ownership".format(
@@ -282,14 +282,14 @@ def list_checkpoints(
          the Event Hubs namespace that contains it.
         :param str consumer_group: The name of the consumer group the checkpoints are associated with.
         :rtype: Iterable[Dict[str,Any]], Iterable of dictionaries containing partition checkpoint information:
-                - `fully_qualified_namespace` (str): The fully qualified namespace that the Event Hub belongs to.
-                  The format is like "<namespace>.servicebus.windows.net".
-                - `eventhub_name` (str): The name of the specific Event Hub the checkpoints are associated with,
-                  relative to the Event Hubs namespace that contains it.
-                - `consumer_group` (str): The name of the consumer group the checkpoints are associated with.
-                - `partition_id` (str): The partition ID which the checkpoint is created for.
-                - `sequence_number` (int): The sequence number of the :class:`EventData<azure.eventhub.EventData>`.
-                - `offset` (str): The offset of the :class:`EventData<azure.eventhub.EventData>`.
+         - `fully_qualified_namespace` (str): The fully qualified namespace that the Event Hub belongs to.
+         The format is like "<namespace>.servicebus.windows.net".
+         - `eventhub_name` (str): The name of the specific Event Hub the checkpoints are associated with,
+         relative to the Event Hubs namespace that contains it.
+         - `consumer_group` (str): The name of the consumer group the checkpoints are associated with.
+         - `partition_id` (str): The partition ID which the checkpoint is created for.
+         - `sequence_number` (int): The sequence number of the :class:`EventData<azure.eventhub.EventData>`.
+         - `offset` (str): The offset of the :class:`EventData<azure.eventhub.EventData>`.
         """
         partition_key = "{} {} {} Checkpoint".format(
             fully_qualified_namespace, eventhub_name, consumer_group
@@ -317,16 +317,17 @@ def update_checkpoint(self, checkpoint, **kwargs):
         Note: If you plan to implement a custom checkpoint store with the intention of running between
         cross-language EventHubs SDKs, it is recommended to persist the offset value as an integer.
         :param Dict[str,Any] checkpoint: A dict containing checkpoint information:
-                - `fully_qualified_namespace` (str): The fully qualified namespace that the Event Hub belongs to.
-                  The format is like "<namespace>.servicebus.windows.net".
-                - `eventhub_name` (str): The name of the specific Event Hub the checkpoint is associated with,
-                  relative to the Event Hubs namespace that contains it.
-                - `consumer_group` (str): The name of the consumer group the checkpoint is associated with.
-                - `partition_id` (str): The partition ID which the checkpoint is created for.
-                - `sequence_number` (int): The sequence number of the :class:`EventData<azure.eventhub.EventData>`
-                  the new checkpoint will be associated with.
-                - `offset` (str): The offset of the :class:`EventData<azure.eventhub.EventData>`
-                  the new checkpoint will be associated with.
+        - `fully_qualified_namespace` (str): The fully qualified namespace that the Event Hub belongs to.
+        The format is like "<namespace>.servicebus.windows.net".
+        - `eventhub_name` (str): The name of the specific Event Hub the checkpoint is associated with,
+        relative to the Event Hubs namespace that contains it.
+        - `consumer_group` (str): The name of the consumer group the checkpoint is associated with.
+        - `partition_id` (str): The partition ID which the checkpoint is created for.
+        - `sequence_number` (int): The sequence number of the :class:`EventData<azure.eventhub.EventData>`
+        the new checkpoint will be associated with.
+        - `offset` (str): The offset of the :class:`EventData<azure.eventhub.EventData>`
+        the new checkpoint will be associated with.
+
         :rtype: None
         """
         checkpoint_entity = TableCheckpointStore._create_checkpoint_entity(
@@ -355,16 +356,16 @@ def claim_ownership(self, ownership_list, **kwargs):
 
         :param Iterable[Dict[str,Any]] ownership_list: Iterable of dictionaries containing all the ownerships to claim.
         :rtype: Iterable[Dict[str,Any]], Iterable of dictionaries containing partition ownership information:
-                - `fully_qualified_namespace` (str): The fully qualified namespace that the Event Hub belongs to.
-                  The format is like "<namespace>.servicebus.windows.net".
-                - `eventhub_name` (str): The name of the specific Event Hub the checkpoint is associated with,
-                  relative to the Event Hubs namespace that contains it.
-                - `consumer_group` (str): The name of the consumer group the ownership are associated with.
-                - `partition_id` (str): The partition ID which the checkpoint is created for.
-                - `owner_id` (str): A UUID representing the owner attempting to claim this partition.
-                - `last_modified_time` (float): The last time this ownership was claimed.
-                - `etag` (str): The Etag value for the last time this ownership was modified. Optional depending
-                  on storage implementation.
+         - `fully_qualified_namespace` (str): The fully qualified namespace that the Event Hub belongs to.
+         The format is like "<namespace>.servicebus.windows.net".
+         - `eventhub_name` (str): The name of the specific Event Hub the checkpoint is associated with,
+         relative to the Event Hubs namespace that contains it.
+         - `consumer_group` (str): The name of the consumer group the ownership are associated with.
+         - `partition_id` (str): The partition ID which the checkpoint is created for.
+         - `owner_id` (str): A UUID representing the owner attempting to claim this partition.
+         - `last_modified_time` (float): The last time this ownership was claimed.
+         - `etag` (str): The Etag value for the last time this ownership was modified. Optional depending
+         on storage implementation.
         """
         gathered_results = []
         for x in ownership_list:

sdk/eventhub/azure-eventhub/azure/eventhub/_constants.py

@@ -67,9 +67,9 @@
 class TransportType(Enum):
     """Transport type
     The underlying transport protocol type:
-     Amqp: AMQP over the default TCP transport protocol, it uses port 5671.
-     AmqpOverWebsocket: Amqp over the Web Sockets transport protocol, it uses
-     port 443.
+    Amqp: AMQP over the default TCP transport protocol, it uses port 5671.
+    AmqpOverWebsocket: Amqp over the Web Sockets transport protocol, it uses
+    port 443.
     """
     Amqp = 1
     AmqpOverWebsocket = 2

sdk/eventhub/azure-eventhub/azure/eventhub/_producer_client.py

@@ -63,24 +63,28 @@ class EventHubProducerClient(
     :paramtype buffer_concurrency: ThreadPoolExecutor or int or None
     :keyword on_success: The callback to be called once a batch has been successfully published.
      The callback takes two parameters:
-        - `events`: The list of events that have been successfully published
-        - `partition_id`: The partition id that the events in the list have been published to.
+     - `events`: The list of events that have been successfully published
+     - `partition_id`: The partition id that the events in the list have been published to.
+
      The callback function should be defined like: `on_success(events, partition_id)`.
      It is required when `buffered_mode` is True while optional if `buffered_mode` is False.
     :paramtype on_success: Optional[Callable[[SendEventTypes, Optional[str]], None]]
     :keyword on_error: The callback to be called once a batch has failed to be published.
      The callback function should be defined like: `on_error(events, partition_id, error)`, where:
-        - `events`: The list of events that failed to be published,
-        - `partition_id`: The partition id that the events in the list have been tried to be published to and
-        - `error`: The exception related to the sending failure.
+     - `events`: The list of events that failed to be published,
+     - `partition_id`: The partition id that the events in the list have been tried to be published to and
+     - `error`: The exception related to the sending failure.
+
      If `buffered_mode` is False, `on_error` callback is optional and errors will be handled as follows:
-        - If an `on_error` callback is passed during the producer client instantiation,
-            then error information will be passed to the `on_error` callback, which will then be called.
-        - If an `on_error` callback is not passed in during client instantiation,
-            then the error will be raised by default.
+     - If an `on_error` callback is passed during the producer client instantiation,
+     then error information will be passed to the `on_error` callback, which will then be called.
+     - If an `on_error` callback is not passed in during client instantiation,
+     then the error will be raised by default.
+
      If `buffered_mode` is True, `on_error` callback is required and errors will be handled as follows:
-        - If events fail to enqueue within the given timeout, then an error will be directly raised.
-        - If events fail to send after enqueuing successfully, the `on_error` callback will be called.
+     - If events fail to enqueue within the given timeout, then an error will be directly raised.
+     - If events fail to send after enqueuing successfully, the `on_error` callback will be called.
+
     :paramtype on_error: Optional[Callable[[SendEventTypes, Optional[str], Exception], None]]
     :keyword int max_buffer_length: Buffered mode only.
      The total number of events per partition that can be buffered before a flush will be triggered.
@@ -444,25 +448,29 @@ def from_connection_string(
         :paramtype buffer_concurrency: ThreadPoolExecutor or int or None
         :keyword on_success: The callback to be called once a batch has been successfully published.
          The callback takes two parameters:
-            - `events`: The list of events that have been successfully published
-            - `partition_id`: The partition id that the events in the list have been published to.
+         - `events`: The list of events that have been successfully published
+         - `partition_id`: The partition id that the events in the list have been published to.
+
          The callback function should be defined like: `on_success(events, partition_id)`.
          Required when `buffered_mode` is True while optional if `buffered_mode` is False.
         :paramtype on_success: Optional[Callable[[SendEventTypes, Optional[str]], None]]
         :keyword on_error: The callback to be called once a batch has failed to be published.
          Required when in `buffered_mode` is True while optional if `buffered_mode` is False.
          The callback function should be defined like: `on_error(events, partition_id, error)`, where:
-            - `events`: The list of events that failed to be published,
-            - `partition_id`: The partition id that the events in the list have been tried to be published to and
-            - `error`: The exception related to the sending failure.
+         - `events`: The list of events that failed to be published,
+         - `partition_id`: The partition id that the events in the list have been tried to be published to and
+         - `error`: The exception related to the sending failure.
+
          If `buffered_mode` is False, `on_error` callback is optional and errors will be handled as follows:
-            - If an `on_error` callback is passed during the producer client instantiation,
-                then error information will be passed to the `on_error` callback, which will then be called.
-            - If an `on_error` callback is not passed in during client instantiation,
-                then the error will be raised by default.
+         - If an `on_error` callback is passed during the producer client instantiation,
+         then error information will be passed to the `on_error` callback, which will then be called.
+         - If an `on_error` callback is not passed in during client instantiation,
+         then the error will be raised by default.
+
          If `buffered_mode` is True, `on_error` callback is required and errors will be handled as follows:
-            - If events fail to enqueue within the given timeout, then an error will be directly raised.
-            - If events fail to send after enqueuing successfully, the `on_error` callback will be called.
+         - If events fail to enqueue within the given timeout, then an error will be directly raised.
+         - If events fail to send after enqueuing successfully, the `on_error` callback will be called.
+
         :paramtype on_error: Optional[Callable[[SendEventTypes, Optional[str], Exception], None]]
         :keyword int max_buffer_length: Buffered mode only.
          The total number of events per partition that can be buffered before a flush will be triggered.
@@ -746,6 +754,7 @@ def create_batch(self, **kwargs: Any) -> EventDataBatch:
                 :language: python
                 :dedent: 4
                 :caption: Create EventDataBatch object within limited size
+
         :rtype: ~azure.eventhub.EventDataBatch
         """
         if not self._max_message_size_on_link: