Interface

def __post_init__(self) -> None:
    """
    Loads the engine class.

    Crucially: The engine instance is not created here. To ensure
    thread safety (especially in free-threaded Python), each method call
    must operate on a new, isolated engine instance.
    """
    self._engine_class = _EngineLoader.load(self.engine)

def __getattr__(self, item: str) -> Any:
    """Delegate attribute access to the underlying engine instance.

    This method is called when an attribute is requested on the `Calculator`
    instance that is not found through normal attribute lookup (i.e., it's
    not a direct attribute of `Calculator` or its class). It then attempts
    to retrieve the attribute from the `_engine_instance`.

    Args:
        item: The name of the attribute to retrieve.

    Returns:
        Any: The value of the attribute from `_engine_instance`.

    Raises:
        AttributeError: If the attribute is not found on either the
            `Calculator` object or its `_engine_instance`.

    Examples:
        >>> calc = Calculator(engine=DEFAULT_ENTRY)
        >>> calc_step = calc.get_calc_step()
        >>> print(calc_step)
        0.0025
        >>> try:
        ...     calc.unknown_method()
        ... except AttributeError as e:
        ...     print(e)
        'Calculator' object or its underlying engine 'RK4IntegrationEngine' has no attribute 'unknown_method'
    """
    engine_instance = self._engine_instance
    if hasattr(engine_instance, item):
        return getattr(engine_instance, item)
    raise AttributeError(
        f"'{self.__class__.__name__}' object or its underlying engine "
        f"'{engine_instance.__class__.__name__}' has no attribute '{item}'"
    )

def __getstate__(self):
    """
    Called by pickle for serialization.
    We only serialize the public fields required for reconstruction.
    We explicitly exclude the calculated fields like _engine_class
    to ensure proper re-initialization in the new process.
    """
    return {"config": self.config, "engine": self.engine}

def __setstate__(self, state):
    """
    Called by pickle for deserialization.
    We manually set the fields and call __post_init__ to reload the engine class.
    """
    # Set the serialized fields
    self.config = state["config"]
    self.engine = state["engine"]
    # Manually run __post_init__ to load the _engine_class
    self.__post_init__()

def barrel_elevation_for_target(self, shot: Shot, target_distance: Union[float, Distance]) -> Angular:
    """Calculate barrel elevation to hit target at zero_distance.

    Args:
        shot: Shot instance we want to zero.
        target_distance: Look-distance to "zero," which is point we want to hit.
            This is the distance that a rangefinder would return with no ballistic adjustment.

    Note:
        Some rangefinders offer an adjusted distance based on inclinometer measurement.
        However, without a complete ballistic model these can only approximate the effects
        on ballistic trajectory of shooting uphill or downhill. Therefore:
        For maximum accuracy, use the raw sight distance and look_angle as inputs here.
    """
    target_distance = PreferredUnits.distance(target_distance)
    total_elevation = self._engine_instance.zero_angle(shot, target_distance)
    return Angular.Radian((total_elevation >> Angular.Radian) - (shot.look_angle >> Angular.Radian))

def set_weapon_zero(self, shot: Shot, zero_distance: Union[float, Distance]) -> Angular:
    """Set shot.weapon.zero_elevation so that it hits a target at zero_distance.

    Args:
        shot: Shot instance to zero.
        zero_distance: Look-distance to "zero," which is point we want to hit.
    """
    shot.weapon.zero_elevation = self.barrel_elevation_for_target(shot, zero_distance)
    return shot.weapon.zero_elevation

def fire(
    self,
    shot: Shot,
    trajectory_range: Union[float, Distance],
    trajectory_step: Optional[Union[float, Distance]] = None,
    *,
    extra_data: bool = False,
    dense_output: bool = False,
    time_step: float = 0.0,
    flags: Union[TrajFlag, int] = TrajFlag.NONE,
    raise_range_error: bool = True,
) -> HitResult:
    """Calculate the trajectory for the given shot parameters.

    Args:
        shot: Shot parameters, including position and barrel angle.
        trajectory_range: Distance at which to stop computing the trajectory.
        trajectory_step: Distance between recorded trajectory points. Defaults to `trajectory_range`.
        extra_data: [DEPRECATED] Requests flags=TrajFlags.ALL and trajectory_step=PreferredUnits.distance(1).
        dense_output: HitResult stores all calculation steps so it can interpolate any point.
        time_step: Maximum time between recorded points. If > 0, points are recorded at least this frequently.
                   Defaults to 0.0.
        flags: Flags for specific points of interest. Defaults to TrajFlag.NONE.
        raise_range_error: If True, raises RangeError if returned by integration.

    Returns:
        HitResult: Object containing computed trajectory.
    """
    trajectory_range = PreferredUnits.distance(trajectory_range)
    dist_step = trajectory_range
    filter_flags = flags
    if trajectory_step:
        dist_step = PreferredUnits.distance(trajectory_step)
        filter_flags |= TrajFlag.RANGE
        if dist_step.raw_value > trajectory_range.raw_value:
            dist_step = trajectory_range

    if extra_data:
        warnings.warn(
            "extra_data is deprecated and will be removed in future versions. "
            "Explicitly specify desired TrajectoryData frequency and flags.",
            DeprecationWarning,
        )
        dist_step = PreferredUnits.distance(1.0)  # << For compatibility with v2.1
        filter_flags = TrajFlag.ALL

    result = self._engine_instance.integrate(
        shot, trajectory_range, dist_step, time_step, filter_flags, dense_output=dense_output
    )
    if result.error and raise_range_error:
        raise result.error
    return result

@staticmethod
def iter_engines() -> Generator[EntryPoint, None, None]:
    """Iterate all available engines in the entry points."""
    yield from _EngineLoader.iter_engines()

@classmethod
def iter_engines(cls) -> Generator[EntryPoint, None, None]:
    """Iterate over all available engines in the entry points."""
    ballistic_entry_points = cls._get_entries_by_group()
    for ep in ballistic_entry_points:
        if ep.name.endswith(cls._entry_point_suffix):
            yield ep