Feature: Increase loading performance

[JeanLucPons]

Description, motivation and use case

The loading time is a bit slow particularly for large lattice.
It mainly comes from the AT element retrieval.

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
  8283408    1.464    0.000    2.336    0.000 attribute_linker.py:66(_test_at_element)
     3738    1.423    0.000    3.758    0.001 lattice_elements_linker.py:75(_iter_matches)
  8314133    0.881    0.000    0.881    0.000 {built-in method builtins.getattr}
   390980    0.267    0.000    0.267    0.000 scanner.py:279(stale_possible_simple_keys)
   372861    0.223    0.000    0.526    0.000 scanner.py:145(need_more_tokens)
    23597    0.189    0.000    0.628    0.000 scanner.py:1270(scan_plain)
  ...

Describe alternatives you've considered
Pre-index AT element in a dict. The loading time is reduced by ~30% (EBSOrbit.yaml)

      self._elements_indexing = {}
      for e in self.ring:
        if e.FamName in self._elements_indexing:             
           self._elements_indexing[e.FamName].append(e)
        else:
           self._elements_indexing[e.FamName] = [e]

I let @gupichon to have a look on how to optimize the LatticeElementsLinker.

[JeanLucPons]

EBSOrbit.yaml loading time (using the above patch):

YAML parsing: 0.994 s
PyAML objects building: 1.117 s
  AT Lattice loading: 0.796 s
Total Loading time (1669 pyaml elements): 2.111 s

Using yaml.load(file,Loader=CLoader) (does not support line mapping for error reporting)

YAML parsing loading: 0.216 s
PyAML objects building: 1.073 s
  AT Lattice loading: 0.812 s
Total Loading time (1669 pyaml elements): 1.289 s

[gupichon]

Index AT elements once in LatticeElementsLinker through two abstract hooks,
replacing the linear scan with a dict lookup.

pyaml/lattice/lattice_elements_linker.py

from typing import Hashable

class LatticeElementsLinker(metaclass=ABCMeta):

    def __init__(self, linker_config_model: LinkerConfigModel):
        self.linker_config_model = linker_config_model
        self.lattice: Lattice = None
        self._index: dict[Hashable, list[at.Element]] = {}

    @abstractmethod
    def _index_key(self, elem: at.Element) -> Hashable | None: ...

    @abstractmethod
    def _identifier_key(self, identifier: LinkerIdentifier) -> Hashable: ...

    def set_lattice(self, lattice: Lattice) -> None:
        self.lattice = lattice
        index: dict[Hashable, list[at.Element]] = {}
        for elem in lattice:
            key = self._index_key(elem)
            if key is not None:
                index.setdefault(key, []).append(elem)
        self._index = index

    def get_at_elements(
        self, element_id: LinkerIdentifier | list[LinkerIdentifier]
    ) -> list[at.Element]:
        identifiers = (
            [element_id] if isinstance(element_id, LinkerIdentifier) else element_id
        )
        results: list[at.Element] = []
        for ident in identifiers:
            results.extend(self._index.get(self._identifier_key(ident), ()))
        if not results:
            raise PyAMLException(
                f"No PyAT elements found for identifier(s): "
                f"{', '.join(repr(i) for i in identifiers)}"
            )
        return results

    def get_at_element(self, element_id: LinkerIdentifier) -> at.Element:
        matches = self._index.get(self._identifier_key(element_id), ())
        if matches:
            return matches[0]
        raise PyAMLException(
            f"No PyAT element found for identifier: {element_id!r}"
        )

_test_at_element and _iter_matches are removed (not used outside the
base class).

pyaml/lattice/attribute_linker.py

class PyAtAttributeElementsLinker(LatticeElementsLinker):

    def get_element_identifier(self, element: Element) -> LinkerIdentifier:
        return PyAtAttributeIdentifier(
            self.linker_config_model.attribute_name, element.get_name()
        )

    def _index_key(self, elem: at.Element) -> Hashable | None:
        return getattr(elem, self.linker_config_model.attribute_name, None)

    def _identifier_key(self, identifier: PyAtAttributeIdentifier) -> Hashable:
        return identifier.identifier

Expected effect

With N = number of identifiers resolved at startup and M = ring size:

• Complexity: O(N·M) → O(M+N).
• _test_at_element: 8.28 M calls → 0 (method removed).
• getattr calls: 8.31 M → ~M (one pass over the ring in set_lattice,
  none during lookup).
• Ring order and identifier-accumulation order preserved (single forward pass,
  insertion-ordered buckets) — tests/test_linkers.py passes unchanged.