feat(devices): add battery profiles

A battery profile describes a battery model: the charge and discharge limit
maps over temperature and SoC, the charge and discharge efficiency curves
over C-rate, the technical SoC bounds, the hard temperature cutoffs and,
for a model, its nominal capacity and power limits. EOS packages the
generic profile generic-lfp; users add their own profiles.

A battery or electric vehicle selects its profile by battery_profile and
describes how the installation differs from it in profile_adjustment
(capacity, power limits of the installation, periodic full charge). The
effective values are resolved from both at the measured operating point
(temperature, SoC, power) and shown as effective_* fields.

The GENETIC simulation uses the limits and efficiencies of the profile over
SoC, with precomputed tables as a fast path; GENETIC0 gets the values at the
operating point. Optimization parameters are always valid: a battery whose
profile is missing, unreadable or invalid uses the packaged generic-lfp
profile, and the former defaults only if that is not usable either; each is
logged as error, and an optimization run is never cancelled because of a
battery.

Additional changes
- Add a generic device profile store: user and packaged profiles, atomic
  saves, compiled profiles cached per file and checked again at most once a
  second, plain file names as profile names ('schema' is reserved). On
  Windows, a save or read that collides with the other is retried briefly.
- Add the REST API /v1/profile to list the profile kinds and to list, read
  (document and JSON schema), save and delete profiles.
- Check the hard temperature cutoffs on the exact temperature.
- Resolve inhibited charging or discharging to a power of 0, e.g. for a cold
  battery; give GENETIC0 its own discharge limit for that.
- Limit generic profiles without own power limits to the former 5000 W.
- Accept only the implemented units; current limits need the nominal
  voltage.
- Migrate legacy battery settings into the profile adjustment, keep the
  former charge power limit as discharge limit (also for a Home Assistant
  entity on it) and report dropped efficiencies as errors.
- Limit GENETIC battery discharge by the discharge power.
- Allow battery profile lookups while the configuration is created.
- Resolve a battery once per configuration dump.
- Package the bundled profiles, document battery profiles and regenerate
  the configuration and OpenAPI documentation.
- Ignore the report PDFs written by the visualization tests.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Assisted-by: Claude Code (claude-opus-5-5)

src/akkudoktoreos/core/coreabc.py

@@ -35,6 +35,9 @@ _measurement_eos: Optional[Measurement] = None
 _prediction_eos: Optional[Prediction] = None
 _resource_registry_eos: Optional[ResourceRegistry] = None
 
+# True while get_config() creates the configuration, see get_config().
+_config_eos_setup_running: bool = False
+
 
 def get_adapter(init: bool = False) -> Adapter:
     """Retrieve the singleton EOS Adapter instance.
@@ -164,10 +167,14 @@ def get_config(init: Union[bool, dict[str, bool]] = False) -> ConfigEOS:
     Returns:
         ConfigEOS: The global EOS configuration singleton instance.
 
+    While the configuration is being created, its settings are loaded before
+    ``ConfigEOS()`` returns. Code that runs during that time, such as a computed
+    field that resolves a battery profile, gets the configuration being created.
+
     Raises:
         RuntimeError:
             If the configuration has not been initialized and ``init`` is
-            ``False``.
+            ``False``, or its settings are not loaded yet.
 
     Usage:
         .. code-block:: python
@@ -187,17 +194,29 @@ def get_config(init: Union[bool, dict[str, bool]] = False) -> ConfigEOS:
             # Access existing configuration
             host = get_config().server.host
     """
-    global _config_eos
+    global _config_eos, _config_eos_setup_running
     if _config_eos is None:
         from akkudoktoreos.config.config import ConfigEOS
 
+        if _config_eos_setup_running:
+            # Called while ConfigEOS() below is running. The instance is
+            # registered already and usable once its settings are loaded.
+            config_in_setup = ConfigEOS._instances.get(ConfigEOS)
+            if config_in_setup is not None and getattr(config_in_setup, "_initialized", False):
+                return config_in_setup
+            raise RuntimeError("Config access before its settings are loaded.")
+
         if not init and not ConfigEOS.documentation_mode():
             raise RuntimeError("Config access before init.")
 
         if isinstance(init, dict):
             ConfigEOS._init_config_eos = init
 
-        _config_eos = ConfigEOS()
+        _config_eos_setup_running = True
+        try:
+            _config_eos = ConfigEOS()
+        finally:
+            _config_eos_setup_running = False
 
     return _config_eos