Added docstrings

Author: tconley1428

temporalio/client.py

@@ -133,6 +133,14 @@ async def connect(
                 metadata doesn't already have an "authorization" key.
             data_converter: Data converter to use for all data conversions
                 to/from payloads.
+            plugins: Set of plugins that are chained together to allow
+                intercepting and modifying client creation and service connection.
+                The earlier plugins wrap the later ones.
+
+                Any plugins that also implement
+                :py:class:`temporalio.worker.Plugin` will be used as worker
+                plugins too so they should not be given when creating a
+                worker.
             interceptors: Set of interceptors that are chained together to allow
                 intercepting of client calls. The earlier interceptors wrap the
                 later ones.
@@ -7391,19 +7399,70 @@ async def _decode_user_metadata(
 
 
 class Plugin:
+    """Base class for client plugins that can intercept and modify client behavior.
+
+    Plugins allow customization of client creation and service connection processes
+    through a chain of responsibility pattern. Each plugin can modify the client
+    configuration or intercept service client connections.
+
+    If the plugin is also a temporalio.worker.Plugin, it will additionally be propagated as a worker plugin.
+    You should likley not also provide it to the worker as that will result in the plugin being applied twice.
+    """
+
     def name(self) -> str:
+        """Get the name of this plugin. Can be overridden if desired to provide a more appropriate name.
+
+        Returns:
+            The fully qualified name of the plugin class (module.classname).
+        """
         return type(self).__module__ + "." + type(self).__qualname__
 
     def init_client_plugin(self, next: Plugin) -> Plugin:
+        """Initialize this plugin in the plugin chain.
+
+        This method sets up the chain of responsibility pattern by storing a reference
+        to the next plugin in the chain. It is called during client creation to build
+        the plugin chain.
+
+        Args:
+            next: The next plugin in the chain to delegate to.
+
+        Returns:
+            This plugin instance for method chaining.
+        """
         self.next_client_plugin = next
         return self
 
     def on_create_client(self, config: ClientConfig) -> ClientConfig:
+        """Hook called when creating a client to allow modification of configuration.
+
+        This method is called during client creation and allows plugins to modify
+        the client configuration before the client is fully initialized. Plugins
+        can add interceptors, modify connection parameters, or change other settings.
+
+        Args:
+            config: The client configuration dictionary to potentially modify.
+
+        Returns:
+            The modified client configuration.
+        """
         return self.next_client_plugin.on_create_client(config)
 
     async def connect_service_client(
         self, config: temporalio.service.ConnectConfig
     ) -> temporalio.service.ServiceClient:
+        """Hook called when connecting to the Temporal service.
+
+        This method is called during service client connection and allows plugins
+        to intercept or modify the connection process. Plugins can modify connection
+        parameters, add authentication, or provide custom connection logic.
+
+        Args:
+            config: The service connection configuration.
+
+        Returns:
+            The connected service client.
+        """
         return await self.next_client_plugin.connect_service_client(config)
 
 

temporalio/worker/_worker.py

@@ -97,17 +97,63 @@ def _to_bridge(self) -> temporalio.bridge.worker.PollerBehavior:
 
 
 class Plugin:
+    """Base class for worker plugins that can intercept and modify worker behavior.
+
+    Plugins allow customization of worker creation and execution processes
+    through a chain of responsibility pattern. Each plugin can modify the worker
+    configuration or intercept worker execution.
+    """
+
     def name(self) -> str:
+        """Get the qualified name of this plugin. Can be overridden if desired to provide a more appropriate name.
+
+        Returns:
+            The fully qualified name of the plugin class (module.classname).
+        """
         return type(self).__module__ + "." + type(self).__qualname__
 
     def init_worker_plugin(self, next: Plugin) -> Plugin:
+        """Initialize this plugin in the plugin chain.
+
+        This method sets up the chain of responsibility pattern by storing a reference
+        to the next plugin in the chain. It is called during worker creation to build
+        the plugin chain.
+
+        Args:
+            next: The next plugin in the chain to delegate to.
+
+        Returns:
+            This plugin instance for method chaining.
+        """
         self.next_worker_plugin = next
         return self
 
     def on_create_worker(self, config: WorkerConfig) -> WorkerConfig:
+        """Hook called when creating a worker to allow modification of configuration.
+
+        This method is called during worker creation and allows plugins to modify
+        the worker configuration before the worker is fully initialized. Plugins
+        can modify task queue names, adjust concurrency settings, add interceptors,
+        or change other worker settings.
+
+        Args:
+            config: The worker configuration dictionary to potentially modify.
+
+        Returns:
+            The modified worker configuration.
+        """
         return self.next_worker_plugin.on_create_worker(config)
 
     async def run_worker(self, worker: Worker) -> None:
+        """Hook called when running a worker to allow interception of execution.
+
+        This method is called when the worker is started and allows plugins to
+        intercept or wrap the worker execution. Plugins can add monitoring,
+        custom lifecycle management, or other execution-time behavior.
+
+        Args:
+            worker: The worker instance to run.
+        """
         await self.next_worker_plugin.run_worker(worker)
 
 
@@ -224,6 +270,10 @@ def __init__(
             workflow_runner: Runner for workflows.
             unsandboxed_workflow_runner: Runner for workflows that opt-out of
                 sandboxing.
+            plugins: Collection of plugins for this worker. Any plugins already
+                on the client that also implement :py:class:`temporalio.worker.Plugin` are
+                prepended to this list and should not be explicitly given here
+                to avoid running the plugin twice.
             interceptors: Collection of interceptors for this worker. Any
                 interceptors already on the client that also implement
                 :py:class:`Interceptor` are prepended to this list and should