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)

tests/test_config.py

@@ -844,7 +844,7 @@ class TestConfigEOSToConfigFile:
 
 class TestDeviceSettings:
     def test_device_map_supplies_stable_identity(self):
-        raw = {"batteries": {"house": {"capacity_wh": 12000}}}
+        raw = {"batteries": {"house": {"profile_adjustment": {"nominal_capacity_wh": 12000}}}}
         a = DevicesCommonSettings.model_validate(raw)
         b = DevicesCommonSettings.model_validate(raw)
         assert a.batteries is not None and b.batteries is not None
@@ -855,6 +855,43 @@ class TestDeviceSettings:
         with pytest.raises(ValidationError, match="device_id"):
             DevicesCommonSettings.model_validate({"batteries": {"house": {"device_id": "other"}}})
 
+    def test_check_battery_profiles_names_unresolvable_devices(self, config_eos):
+        # generic-lfp provides no capacity: the house battery lacks it, the car has it.
+        devices = DevicesCommonSettings.model_validate(
+            {
+                "batteries": {"house": {}},
+                "electric_vehicles": {"car": {"profile_adjustment": {"nominal_capacity_wh": 60000}}},
+            }
+        )
+        errors, warnings = devices.check_battery_profiles()
+        assert len(errors) == 1
+        assert "Battery 'house'" in errors[0]
+        assert warnings == []
+
+    def test_config_logs_battery_profile_problems_once(self, config_eos, monkeypatch):
+        from loguru import logger
+
+        monkeypatch.setattr(ConfigEOS, "_battery_profile_problems", ((), ()))
+        messages: list[str] = []
+        sink_id = logger.add(
+            lambda message: messages.append(message.record["message"]), level="WARNING"
+        )
+        try:
+            config_eos.merge_settings_from_dict({"devices": {"batteries": {"house": {}}}})
+            config_eos.merge_settings_from_dict({"devices": {"max_batteries": 1}})
+            unresolvable = [m for m in messages if "Battery 'house'" in m]
+            # Logged on the change only, not again on the unrelated update.
+            assert len(unresolvable) == 1
+
+            messages.clear()
+            config_eos.set_nested_value(
+                "devices/batteries/house/profile_adjustment/nominal_capacity_wh", 10000
+            )
+            assert not [m for m in messages if "Battery 'house'" in m]
+            assert ConfigEOS._battery_profile_problems == ((), ())
+        finally:
+            logger.remove(sink_id)
+
 
 class TestConfigProviderValidation:
     """Provider ids are validated while the configuration is created."""
@@ -924,3 +961,70 @@ class TestDocumentationMode:
         assert settings.keys == ["a", "b"]
         monkeypatch.setattr(ConfigEOS, "_force_documentation_mode", True)
         assert settings.keys == []
+
+
+class TestConfigSetup:
+    """The configuration can be created when its computed fields need it.
+
+    A battery's computed fields resolve the battery profile, and the profile
+    store reads its directories from the configuration. Rendering the
+    configuration while ``ConfigEOS()`` is still being created must not fail.
+    """
+
+    @pytest.fixture
+    def uncreated_config_with_battery(self, uncreated_config: Path) -> None:
+        """Write a config file with a battery; get_config(init=True) creates the configuration."""
+        uncreated_config.write_text(
+            json.dumps(
+                {
+                    "devices": {
+                        "batteries": {
+                            "battery1": {
+                                "device_id": "battery1",
+                                "profile_adjustment": {"nominal_capacity_wh": 10240},
+                            }
+                        }
+                    }
+                }
+            )
+        )
+
+    def test_config_with_battery_is_created(self, uncreated_config_with_battery):
+        from akkudoktoreos.core.coreabc import get_config
+
+        config = get_config(init=True)
+
+        assert config.devices.batteries is not None
+        assert config.devices.batteries["battery1"].effective_nominal_capacity_wh == 10240
+
+    def test_config_with_battery_is_created_with_trace_logging(
+        self, uncreated_config_with_battery
+    ):
+        """With trace logging the configuration is rendered during its creation."""
+        from loguru import logger
+
+        from akkudoktoreos.core.coreabc import get_config
+
+        messages: list[str] = []
+        sink_id = logger.add(
+            lambda message: messages.append(message.record["message"]), level="TRACE"
+        )
+        try:
+            config = get_config(init=True)
+        finally:
+            logger.remove(sink_id)
+
+        assert config.devices.batteries is not None
+        assert "battery1" in config.devices.batteries
+        setup_messages = [m for m in messages if m.startswith("Config setup:")]
+        assert len(setup_messages) == 1
+        assert "effective_nominal_capacity_wh=10240" in setup_messages[0]
+
+    def test_access_before_settings_are_loaded_raises(self, uncreated_config, monkeypatch):
+        """During creation the configuration is usable only once its settings are loaded."""
+        from akkudoktoreos.core import coreabc
+
+        monkeypatch.setattr(coreabc, "_config_eos_setup_running", True)
+
+        with pytest.raises(RuntimeError, match="before its settings are loaded"):
+            coreabc.get_config(init=True)