Suppress boilerplate warnings from pydantic error messages:

[jewettaijfc]

User-facing pydantic error messages are frequently unnecessarily long because they list warning messages for every single validator that failed to run (as well as stack-traces).

Example input

import tidy3d as td

source = td.UniformCurrentSource(
    center=(0, -1.0, 0),
    size=(1, 0, 0.5),
    polarization="Ex",
    source_time=td.GaussianPulse(
        freq0=100e14,
        fwidth=10e14,
    ),
)

# make simulation
sim = td.Simulation(
    size=(1, 1, 1),
    grid_spec=td.GridSpec.auto(wavelength=4),
    boundary_spec=td.BoundarySpec(
        x=td.Boundary.pml(num_layers=10),
        y=td.Boundary.periodic(),
        z=td.Boundary.pml(num_layers=10),
    ),
    sources=[source],
    run_time=1e-12,
)

Example output

14:39:13 EDT ERROR: simulation.sources[0] is outside of the simulation domain.  
             WARNING: Could not execute validator 'plane_wave_boundaries'       
             because field 'sources' failed validation.                         
             WARNING: Could not execute validator 'tfsf_boundaries' because     
             field 'sources' failed validation.                                 
             WARNING: Could not execute validator '_structures_not_close_pml'   
             because field 'sources' failed validation.                         
             WARNING: Could not execute validator 'bloch_boundaries_diff_mnt'   
             because field 'sources' failed validation.                         
             WARNING: Could not execute validator                               
             '_warn_monitor_simulation_frequency_range' because field 'sources' 
             failed validation.                                                 
             WARNING: Could not execute validator                               
             '_validate_auto_grid_wavelength' because field 'sources' failed    
             validation.                                                        
             WARNING: Could not execute validator '_warn_grid_size_too_small'   
             because field 'sources' failed validation.                         
             WARNING: Could not execute validator '_check_normalize_index'      
             because field 'sources' failed validation.                         
             WARNING: Could not execute validator 'check_fixed_angle_components'
             because field 'sources' failed validation.                         
---------------------------------------------------------------------------
ValidationError                           Traceback (most recent call last)
Cell In[7], line 16
     13 monitor = td.FieldMonitor(center=(-1.0, 0, 0), size=(0.5, 0, 1), freqs=[100e14], name="field_monitor_1")
     15 # make simulation
---> 16 sim = td.Simulation(
     17     size=(1, 1, 1),
     18     grid_spec=td.GridSpec.auto(wavelength=4),
     19     boundary_spec=td.BoundarySpec(
     20         x=td.Boundary.pml(num_layers=10),
     21         y=td.Boundary.periodic(),
     22         z=td.Boundary.pml(num_layers=10),
     23     ),
     24     # structures=[structure],
     25     sources=[source],
     26     # monitors=[monitor],
     27     run_time=1e-12,
     28 )

File [~/tidy3d/tidy3d/components/base.py:147](http://localhost:8888/home/jewett/tidy3d/tidy3d/components/base.py#line=146), in Tidy3dBaseModel.__init__(self, **kwargs)
    145 """Init method, includes post-init validators."""
    146 log.begin_capture()
--> 147 super().__init__(**kwargs)
    148 self._post_init_validators()
    149 log.end_capture(self)

File [~/anaconda3/envs/tidy3d_frontend_dev/lib/python3.11/site-packages/pydantic/v1/main.py:347](http://localhost:8888/home/jewett/anaconda3/envs/tidy3d_frontend_dev/lib/python3.11/site-packages/pydantic/v1/main.py#line=346), in BaseModel.__init__(__pydantic_self__, **data)
    345 values, fields_set, validation_error = validate_model(__pydantic_self__.__class__, data)
    346 if validation_error:
--> 347     raise validation_error
    348 try:
    349     object_setattr(__pydantic_self__, '__dict__', values)

ValidationError: 1 validation error for Simulation
sources
  simulation.sources[0] is outside of the simulation domain. (type=value_error.setup)

Requested solution:

Would it be possible to suppress these extra warning messages by default, so that our users see something like this instead?:

ValidationError: 1 validation error for Simulation
sources
  simulation.sources[0] is outside of the simulation domain. (type=value_error.setup)

(Simplifying the ugly stack trace is a separate issue.)

Priority

Low. (User complaints and requests should come first.)

It can wait until after the pydantic v2 refactor.

[jewettaijfc]

Perhaps it makes sense to worry about this after pydantic is refactored for v2. Feel free to postpone this.

[jewettaijfc]

Stack trace

Pydantic stack traces are always a bit ugly due to the last several layers of pydantic-specific function calls.

It would be great if there were an easy way to shorten the ugly stack trace, so that they stop at the last line of user-generated code (ie. ---> 16 sim = td.Simulation( in the example above).

I can't imagine this is easy to do, and simplifying stack traces (if possible) should be separate issue. (This issue is only about supressiong unnecessary warning messages.)

[momchil-flex]

This actually goes back to a veeeery early discussion we had about this. Essentially, while there are ways to do it, it's considered bad practice for many reasons. The solution we decided upon then is to log the errors so that they appear on top. If you look at your output,

14:39:13 EDT ERROR: simulation.sources[0] is outside of the simulation domain.  
             WARNING: Could not execute validator 'plane_wave_boundaries'       
             because field 'sources' failed validation.                         
             WARNING: Could not execute validator 'tfsf_boundaries' because     
             field 'sources' failed validation.                                 
             WARNING: Could not execute validator '_structures_not_close_pml'   
             because field 'sources' failed validation.                         
             WARNING: Could not execute validator 'bloch_boundaries_diff_mnt'   
             because field 'sources' failed validation.                         
             WARNING: Could not execute validator                               
             '_warn_monitor_simulation_frequency_range' because field 'sources' 
             failed validation.                                                 
             WARNING: Could not execute validator                               
             '_validate_auto_grid_wavelength' because field 'sources' failed    
             validation.                                                        
             WARNING: Could not execute validator '_warn_grid_size_too_small'   
             because field 'sources' failed validation.                         
             WARNING: Could not execute validator '_check_normalize_index'      
             because field 'sources' failed validation.                         
             WARNING: Could not execute validator 'check_fixed_angle_components'
             because field 'sources' failed validation.                         
---------------------------------------------------------------------------
ValidationError                           Traceback (most recent call last)
Cell In[7], line 16
     13 monitor = td.FieldMonitor(center=(-1.0, 0, 0), size=(0.5, 0, 1), freqs=[100e14], name="field_monitor_1")
     15 # make simulation
---> 16 sim = td.Simulation(
     17     size=(1, 1, 1),
     18     grid_spec=td.GridSpec.auto(wavelength=4),
     19     boundary_spec=td.BoundarySpec(
     20         x=td.Boundary.pml(num_layers=10),
     21         y=td.Boundary.periodic(),
     22         z=td.Boundary.pml(num_layers=10),
     23     ),
     24     # structures=[structure],
     25     sources=[source],
     26     # monitors=[monitor],
     27     run_time=1e-12,
     28 )

File [~/tidy3d/tidy3d/components/base.py:147](http://localhost:8888/home/jewett/tidy3d/tidy3d/components/base.py#line=146), in Tidy3dBaseModel.__init__(self, **kwargs)
    145 """Init method, includes post-init validators."""
    146 log.begin_capture()
--> 147 super().__init__(**kwargs)
    148 self._post_init_validators()
    149 log.end_capture(self)

File [~/anaconda3/envs/tidy3d_frontend_dev/lib/python3.11/site-packages/pydantic/v1/main.py:347](http://localhost:8888/home/jewett/anaconda3/envs/tidy3d_frontend_dev/lib/python3.11/site-packages/pydantic/v1/main.py#line=346), in BaseModel.__init__(__pydantic_self__, **data)
    345 values, fields_set, validation_error = validate_model(__pydantic_self__.__class__, data)
    346 if validation_error:
--> 347     raise validation_error
    348 try:
    349     object_setattr(__pydantic_self__, '__dict__', values)

ValidationError: 1 validation error for Simulation
sources
  simulation.sources[0] is outside of the simulation domain. (type=value_error.setup)

The same error message you get in the end also appears on the first line!

[jewettaijfc]

Thanks for your reply @momchil-flex . I will close this issue.

[jewettaijfc]

Incidentally,python's built-in warnings module has a way to filter out warnings that match a pattern (eg. ".*Could not execute validator.*because field.*failed validation.*") and/or were launched from certain modules (eg. "pydantic.*").

warnings.filterwarnings(
    "ignore",
    message=".*Could not execute validator.*because field.*failed validation.*",
    category=UserWarning,
    module="pydantic.*",
)

I realize our code uses tidy3d.log.warning(), and I'm not suggesting we change that. I just mention this to point out that it is a common problem.

[jewettaijfc]

Simplifying the stack trace

It is possible to strip pydantic-related crud from the stack-trace. But we would have to override python's default exception handler (sys.excepthook) to globally format tracebacks. This will affect all uncaught exceptions, so I'm not proposing this as a solution. For what it's worth, I asked google-gemini to solve this problem. This is what it came up with:

import sys
import traceback
from pydantic import BaseModel, ValidationError, Field

# Original excepthook to fall back to or chain
original_excepthook = sys.excepthook

def custom_exception_hook(exc_type, exc_value, tb):
    if issubclass(exc_type, ValidationError):
        # Filter out Pydantic internal frames
        filtered_tb = []
        current_tb = tb
        while current_tb:
            frame = current_tb.tb_frame
            # This heuristic might need refinement based on Pydantic's internal paths
            if "pydantic" not in frame.f_code.co_filename:
                filtered_tb.append(traceback.FrameSummary(
                    filename=frame.f_code.co_filename,
                    lineno=frame.f_lineno,
                    name=frame.f_code.co_name,
                    line=linecache.getline(frame.f_code.co_filename, frame.f_lineno).strip()
                ))
            current_tb = current_tb.tb_next

        # Reverse to show most recent first (like standard traceback)
        filtered_tb.reverse()

        # Format and print the filtered traceback
        print("\n--- Validation Error ---")
        print(f"Error: {exc_value}")
        if filtered_tb:
            formatted_trace = "\n".join(traceback.format_list(filtered_tb))
            print("Traceback (most recent call last):\n" + formatted_trace)
        else:
            print("(Note: Traceback truncated to user code.)")
        print("(Note: Pydantic internal frames were suppressed.)")

    else:
        # For other exceptions, use the original hook
        original_excepthook(exc_type, exc_value, tb)

# Install the custom hook
import linecache # Needed for linecache.getline in FrameSummary
sys.excepthook = custom_exception_hook

Later in the user's code:

class MyModel(BaseModel):
    my_field: int = Field(gt=10)

def my_bad_function(value):
    MyModel(my_field=value) # This will raise a ValidationError

def user_entry_point():
    print("Calling my_bad_function with invalid data...")
    my_bad_function(5)

user_entry_point()

This generates the following simpler output:

Calling my_bad_function with invalid data...

--- Validation Error ---
Error: 1 validation error for MyModel
my_field
  Input should be greater than 10 [type=greater_than, input_value=5, input_type=int]
    For further information visit https://errors.pydantic.dev/2.11/v/greater_than
Traceback (most recent call last):
  File "<stdin>", line 2, in my_bad_function

  File "<stdin>", line 3, in user_entry_point

  File "<stdin>", line 1, in <module>

(Note: Pydantic internal frames were suppressed.)

Much prettier!
(I'm not suggesting we do this. And if we did, we'd definitely want to change it so that overriding the default sys.excepthook behavior is optional. Users might not want to see pydantic details. But developers do.)

[momchil-flex]

Curious if Gemini advises against it or if it thinks it's fine? :)

[yaugenst-flex]

Not Gemini, but I'd say modifying sys.excepthook is a bad idea, this is a global change for a local problem that goes far beyond the scope of what we can allow tidy3d to do. I think a more feasible path if we wanted to look into this a bit more would be to catch failed model construction in Tidy3dBaseModel.__init__() and filter the errors there.

[jewettaijfc]

Perhaps we can modify our ValidatorException's __traceback__ instead. This won't affect exceptions thrown by other people's code. (See below.)

Curious if Gemini advises against it or if it thinks it's fine? :)

Hi Momchil! First of all, here's a link to the full conversation, including the prompt I used: google-drive-link

Here's a summary:
Gemini had 3 suggestions, including:

1. customizing the exception __traceback__
2. customizing sys.excepthook (global setting)
3. using the rich module.

Gemini concluded with:
"For most practical applications, using a library like rich is the best approach. (<--EDIT: I disagree!) If rich isn't an option for some reason, the sys.excepthook approach gives you global control, but be prepared for more complex maintenance. Directly modifying e.__traceback__ is generally only practical for very specific, localized error handling where you need extreme precision." (?)

Yannick mentioned that Tidy3D users are often experienced python programmers. They might be using pydantic themselves. So we don't want to suppress all pydantic stack trace frames because it would filter out pydantic stack details they might want to see when their own code is failing. Are we willing to suppress pydantic stack-frames generated by our code? (We could turn this on and off.) To do that, perhaps we could combine strategy 1 with Yanick's idea: We could put a try...except block in Tidy3dBaseModel.__init__() and modify the __traceback__ to omit the pydantic stuff.

class Tidy3dBaseModel(pydantic.BaseModel):
   :
def __init__(self, **kwargs):
    """Init method, includes post-init validators."""
    try:
        # ... The original contents of Tidy3dBaseModel.__init__() goes here:
        log.begin_capture()  # <-- (should this be in the try block?)
        super().__init__(**kwargs)
        self._post_init_validators()
        log.end_capture(self)  # <-- (should this be in the try block?)
    except ValidationError as e:
        # I AM BLINDLY COPYING GEMINI'S CODE BELOW.  (See google-drive-link for the original context.)
        # Get the original traceback
        tb = e.__traceback__
        # Find the frame where the Pydantic internal calls begin.
        # This is often where your custom validator or BaseModel.__init__ is called.
        # We'll stop *before* Pydantic's internal validation loop.
        current_tb = tb
        while current_tb:
            frame = current_tb.tb_frame
            # Identify a pattern for Pydantic's internal files.
            # Common patterns include 'pydantic/main.py', 'pydantic/fields.py', etc.
            # This is a bit of a heuristic.
            if Tidy3dBaseModel.suppress_pydantic and "pydantic" in frame.f_code.co_filename:
                # We've hit a Pydantic internal frame.
                # The previous frame is likely where your code called Pydantic.
                if current_tb.tb_next: # If there's a frame after the current one
                    # We want to skip all frames from `current_tb` onwards
                    # by setting the traceback to the frame *before* `current_tb`.
                    new_tb = current_tb.tb_next # This is actually the frame *after* current_tb
                    # To get the frame *before* `current_tb`, you'd need to iterate
                    # and keep track of the previous one. Let's refine this:
                    previous_tb = None
                    temp_tb = tb
                    while temp_tb and temp_tb != current_tb:
                        previous_tb = temp_tb
                        temp_tb = temp_tb.tb_next

                    if previous_tb:
                        e.__traceback__ = previous_tb # Set the traceback to the frame *before* Pydantic's internal calls
                    else:
                        # If Pydantic was called directly from the top-level or very early,
                        # we might just want to show the exception itself.
                        e.__traceback__ = None
                    break
            current_tb = current_tb.tb_next

        # Optionally add a custom message
        print("\n--- Validation Error ---")
        print(f"Error: {e}")
        if e.__traceback__ is not None:
            # Print the modified traceback
            traceback.print_exception(type(e), e, e.__traceback__)
        print("(Note: Tidy3d-Pydantic-specific stack frames were omitted.)")
        sys.exit(1)

(Here I added a global variable Tidy3dBaseModel.suppress_pydantic to disable this behavior. This code is untested.)