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_genetic0optimize.py

@@ -169,3 +169,62 @@ async def test_optimize(
 
     # Everything passed, remove generated files
     TESTDATA_FILE.unlink()
+
+
+class TestGenetic0SocClampedOperationFactors:
+    """The SOC clamping uses the optimizer battery parameters, not the settings.
+
+    Battery settings no longer hold capacity / efficiency / power fields (they
+    come from the battery profile), so reading them from the settings fails.
+    """
+
+    @pytest.fixture
+    def solution(self, config_eos: ConfigEOS) -> Genetic0Solution:
+        # A configured battery whose settings differ from the solution parameters.
+        config_eos.merge_settings_from_dict(
+            {
+                "devices": {
+                    "max_batteries": 1,
+                    "batteries": {
+                        "battery1": {"device_id": "battery1", "profile_adjustment": {"nominal_capacity_wh": 8000}}
+                    },
+                    "max_inverters": 0,
+                    "inverters": None,
+                }
+            }
+        )
+        data = json.loads((DIR_TESTDATA / "optimize_result_1.json").read_text())
+        return Genetic0Solution.model_validate(data)
+
+    def test_uses_solution_battery_parameters(self, solution):
+        bat = solution.parameters.pv_battery
+        assert bat is not None
+        assert bat.capacity_wh == 26400
+        # 1 % headroom of 26400 Wh against one hour at 5000 W and the charging
+        # efficiency of the parameters (no inverter configured).
+        headroom_wh = 0.01 * bat.capacity_wh
+        expected = headroom_wh / (bat.max_charge_power_w * bat.charging_efficiency)
+        ac, dc, dis = solution._soc_clamped_operation_factors(
+            1.0, 1.0, True, float(bat.max_soc_percentage) - 1.0
+        )
+        assert ac == pytest.approx(expected)
+        assert dc == pytest.approx(1.0)
+        assert dis is True
+
+    def test_full_and_empty_battery(self, solution):
+        bat = solution.parameters.pv_battery
+        assert solution._soc_clamped_operation_factors(
+            1.0, 1.0, True, float(bat.max_soc_percentage)
+        ) == (0.0, 0.0, True)
+        assert solution._soc_clamped_operation_factors(
+            0.0, 0.0, True, float(bat.min_soc_percentage)
+        ) == (0.0, 0.0, False)
+
+    def test_without_battery_parameters_factors_are_unchanged(self, solution):
+        solution.parameters.pv_battery = None
+        assert solution._soc_clamped_operation_factors(1.0, 0.5, True, 50.0) == (1.0, 0.5, True)
+
+    @pytest.mark.asyncio
+    async def test_optimization_solution_with_configured_battery(self, solution):
+        optimization_solution = await solution.optimization_solution()
+        assert optimization_solution is not None