add some debugging msg.

Author: shunping

sdks/python/apache_beam/pipeline.py

@@ -561,9 +561,11 @@ def run(self, test_runner_api: Union[bool, str] = 'AUTO') -> 'PipelineResult':
     """Runs the pipeline. Returns whatever our runner returns after running."""
     # All pipeline options are finalized at this point.
     # Call get_all_options to print warnings on invalid options.
-    self.options.get_all_options(
+    opts = self.options.get_all_options(
         retain_unknown_options=True, display_warnings=True)
 
+    logging.exception("all_options:" + str(opts))
+    logging.exception('runner class:' + str(self.runner))
     for error_handler in self._error_handlers:
       error_handler.verify_closed()
 
@@ -867,7 +869,7 @@ def _infer_result_type(
       inputs: Sequence[Union[pvalue.PBegin, pvalue.PCollection]],
       result_pcollection: Union[pvalue.PValue, pvalue.DoOutputsTuple]) -> None:
     """Infer and set the output element type for a PCollection.
-    
+
     This function determines the output types of transforms by combining:
     1. Concrete input types from previous transforms
     2. Type hints declared on the current transform
@@ -878,43 +880,43 @@ def _infer_result_type(
     Type variables (K, V, T, etc.) act as placeholders that get bound to
     concrete types through pattern matching. This requires both an input
     pattern and an output template:
-    
+
     Input Pattern (from .with_input_types()):
         Defines where in the input to find each type variable
         Example: Tuple[K, V] means "K is the first element, V is the second"
-    
+
     Output Template (from .with_output_types()):
         Defines how to use the bound variables in the output
         Example: Tuple[V, K] means "swap the positions"
-    
+
     CONCRETE TYPES VS TYPE VARIABLES
     ---------------------------------
     The system handles these differently:
-    
+
     Concrete Types (e.g., str, int, Tuple[str, int]):
         - Used as-is without any binding
         - Do not fall back to Any
         - Example: .with_output_types(Tuple[str, int]) → Tuple[str, int]
-    
+
     Type Variables (e.g., K, V, T):
         - Must be bound through pattern matching
         - Require .with_input_types() to provide the pattern
         - Fall back to Any if not bound
         - Example without pattern: Tuple[K, V] → Tuple[Any, Any]
         - Example with pattern: Tuple[K, V] → Tuple[str, int]
-    
+
     BINDING ALGORITHM
     -----------------
     1. Match: Compare input pattern to concrete input
        Pattern:  Tuple[K, V]
        Concrete: Tuple[str, int]
        Result:   {K: str, V: int}  ← Bindings created
-    
+
     2. Substitute: Apply bindings to output template
        Template: Tuple[V, K]  ← Note: swapped!
        Bindings: {K: str, V: int}
        Result:   Tuple[int, str]  ← Swapped concrete types
-    
+
     Each transform operates in its own type inference scope. Type variables
     declared in a parent composite transform do NOT automatically propagate
     to child transforms.
@@ -925,36 +927,36 @@ class MyComposite(PTransform):
             def expand(self, pcoll):
                 # Child scope - parent's K, V are NOT available
                 return pcoll | ChildTransform()
-    
+
     Type variables that remain unbound after inference fall back to Any:
-    
+
     EXAMPLES
     --------
     Example 1: Concrete types (no variables)
         Input:  Tuple[str, int]
         Transform: .with_output_types(Tuple[str, int])
         Output: Tuple[str, int]  ← Used as-is
-    
+
     Example 2: Type variables with pattern (correct)
         Input:  Tuple[str, int]
         Transform: .with_input_types(Tuple[K, V])
                    .with_output_types(Tuple[V, K])
         Binding: {K: str, V: int}
         Output: Tuple[int, str]  ← Swapped!
-    
+
     Example 3: Type variables without pattern (falls back to Any)
         Input:  Tuple[str, int]
         Transform: .with_output_types(Tuple[K, V])  ← No input pattern!
         Binding: None (can't match)
         Output: Tuple[Any, Any]  ← Fallback
-    
+
     Example 4: Mixed concrete and variables
         Input:  Tuple[str, int]
         Transform: .with_input_types(Tuple[str, V])
                    .with_output_types(Tuple[str, V])
         Binding: {V: int}  ← Only V needs binding
         Output: Tuple[str, int]  ← str passed through, V bound to int
-    
+
     Args:
         transform: The PTransform being applied
         inputs: Input PCollections (provides concrete types)

sdks/python/apache_beam/runners/portability/fn_api_runner/worker_handlers.py

@@ -475,6 +475,7 @@ def __init__(
         ("grpc.http2.min_ping_interval_without_data_ms", 20_000),
     ]
 
+    _LOGGER.exception("Starting a few grpc server with options:" + str(options))
     self.state = state
     self.provision_info = provision_info
     self.control_server = grpc.server(

sdks/python/setup.py

@@ -14,6 +14,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
+# Modify setup.py to trigger more tests.
 
 """Apache Beam SDK for Python setup file."""
 import glob