pytest-homeassistant-custom-component 0.13.307__py3-none-any.whl → 0.13.309__py3-none-any.whl

pytest_homeassistant_custom_component/common.py

@@ -705,6 +705,7 @@ class RegistryEntryWithDefaults(er.RegistryEntry):
         converter=attr.converters.default_if_none(factory=uuid_util.random_uuid_hex),  # type: ignore[misc]
     )
     has_entity_name: bool = attr.ib(default=False)
+    object_id_base: str | None = attr.ib(default=None)
     options: er.ReadOnlyEntityOptionsType = attr.ib(
         default=None, converter=er._protect_entity_options
     )

pytest_homeassistant_custom_component/components/__init__.py

@@ -7,13 +7,18 @@ This file is originally from homeassistant/core and modified by pytest-homeassis
 from collections.abc import Iterable
 from enum import StrEnum
 import itertools
-from typing import TypedDict
+from typing import Any, TypedDict
+
+import pytest
 
 from homeassistant.const import (
     ATTR_AREA_ID,
     ATTR_DEVICE_ID,
     ATTR_FLOOR_ID,
     ATTR_LABEL_ID,
+    CONF_ABOVE,
+    CONF_BELOW,
+    CONF_CONDITION,
     CONF_ENTITY_ID,
     CONF_OPTIONS,
     CONF_PLATFORM,
@@ -29,6 +34,16 @@ from homeassistant.helpers import (
     floor_registry as fr,
     label_registry as lr,
 )
+from homeassistant.helpers.condition import (
+    ConditionCheckerTypeOptional,
+    async_from_config as async_condition_from_config,
+)
+from homeassistant.helpers.trigger import (
+    CONF_LOWER_LIMIT,
+    CONF_THRESHOLD_TYPE,
+    CONF_UPPER_LIMIT,
+    ThresholdType,
+)
 from homeassistant.setup import async_setup_component
 
 from ..common import MockConfigEntry, mock_device_registry
@@ -89,6 +104,13 @@ async def target_entities(
         suggested_object_id=f"device_{domain}",
         device_id=device.id,
     )
+    entity_reg.async_get_or_create(
+        domain=domain,
+        platform="test",
+        unique_id=f"{domain}_device2",
+        suggested_object_id=f"device2_{domain}",
+        device_id=device.id,
+    )
     entity_reg.async_get_or_create(
         domain=domain,
         platform="test",
@@ -119,9 +141,11 @@ async def target_entities(
     return {
         "included": [
             f"{domain}.standalone_{domain}",
+            f"{domain}.standalone2_{domain}",
             f"{domain}.label_{domain}",
             f"{domain}.area_{domain}",
             f"{domain}.device_{domain}",
+            f"{domain}.device2_{domain}",
         ],
         "excluded": [
             f"{domain}.standalone_{domain}_excluded",
@@ -139,44 +163,206 @@ def parametrize_target_entities(domain: str) -> list[tuple[dict, str, int]]:
     """
     return [
         (
-            {CONF_ENTITY_ID: f"{domain}.standalone_{domain}"},
+            {
+                CONF_ENTITY_ID: [
+                    f"{domain}.standalone_{domain}",
+                    f"{domain}.standalone2_{domain}",
+                ]
+            },
             f"{domain}.standalone_{domain}",
-            1,
+            2,
         ),
-        ({ATTR_LABEL_ID: "test_label"}, f"{domain}.label_{domain}", 2),
-        ({ATTR_AREA_ID: "test_area"}, f"{domain}.area_{domain}", 2),
-        ({ATTR_FLOOR_ID: "test_floor"}, f"{domain}.area_{domain}", 2),
-        ({ATTR_LABEL_ID: "test_label"}, f"{domain}.device_{domain}", 2),
-        ({ATTR_AREA_ID: "test_area"}, f"{domain}.device_{domain}", 2),
-        ({ATTR_FLOOR_ID: "test_floor"}, f"{domain}.device_{domain}", 2),
-        ({ATTR_DEVICE_ID: "test_device"}, f"{domain}.device_{domain}", 1),
+        ({ATTR_LABEL_ID: "test_label"}, f"{domain}.label_{domain}", 3),
+        ({ATTR_AREA_ID: "test_area"}, f"{domain}.area_{domain}", 3),
+        ({ATTR_FLOOR_ID: "test_floor"}, f"{domain}.area_{domain}", 3),
+        ({ATTR_LABEL_ID: "test_label"}, f"{domain}.device_{domain}", 3),
+        ({ATTR_AREA_ID: "test_area"}, f"{domain}.device_{domain}", 3),
+        ({ATTR_FLOOR_ID: "test_floor"}, f"{domain}.device_{domain}", 3),
+        ({ATTR_DEVICE_ID: "test_device"}, f"{domain}.device_{domain}", 2),
     ]
 
 
 class _StateDescription(TypedDict):
-    """Test state and expected service call count."""
+    """Test state with attributes."""
 
     state: str | None
     attributes: dict
 
 
-class StateDescription(TypedDict):
+class TriggerStateDescription(TypedDict):
     """Test state and expected service call count."""
 
-    included: _StateDescription
-    excluded: _StateDescription
-    count: int
+    included: _StateDescription  # State for entities meant to be targeted
+    excluded: _StateDescription  # State for entities not meant to be targeted
+    count: int  # Expected service call count
+
+
+class ConditionStateDescription(TypedDict):
+    """Test state and expected condition evaluation."""
+
+    included: _StateDescription  # State for entities meant to be targeted
+    excluded: _StateDescription  # State for entities not meant to be targeted
+
+    condition_true: bool  # If the condition is expected to evaluate to true
+    condition_true_first_entity: bool  # If the condition is expected to evaluate to true for the first targeted entity
+
+
+def _parametrize_condition_states(
+    *,
+    condition: str,
+    condition_options: dict[str, Any] | None = None,
+    target_states: list[str | None | tuple[str | None, dict]],
+    other_states: list[str | None | tuple[str | None, dict]],
+    additional_attributes: dict | None,
+    condition_true_if_invalid: bool,
+) -> list[tuple[str, dict[str, Any], list[ConditionStateDescription]]]:
+    """Parametrize states and expected condition evaluations.
+
+    The target_states and other_states iterables are either iterables of
+    states or iterables of (state, attributes) tuples.
+
+    Returns a list of tuples with (condition, condition options, list of states),
+    where states is a list of ConditionStateDescription dicts.
+    """
+
+    additional_attributes = additional_attributes or {}
+    condition_options = condition_options or {}
+
+    def state_with_attributes(
+        state: str | None | tuple[str | None, dict],
+        condition_true: bool,
+        condition_true_first_entity: bool,
+    ) -> ConditionStateDescription:
+        """Return ConditionStateDescription dict."""
+        if isinstance(state, str) or state is None:
+            return {
+                "included": {
+                    "state": state,
+                    "attributes": additional_attributes,
+                },
+                "excluded": {
+                    "state": state,
+                    "attributes": {},
+                },
+                "condition_true": condition_true,
+                "condition_true_first_entity": condition_true_first_entity,
+            }
+        return {
+            "included": {
+                "state": state[0],
+                "attributes": state[1] | additional_attributes,
+            },
+            "excluded": {
+                "state": state[0],
+                "attributes": state[1],
+            },
+            "condition_true": condition_true,
+            "condition_true_first_entity": condition_true_first_entity,
+        }
+
+    return [
+        (
+            condition,
+            condition_options,
+            list(
+                itertools.chain(
+                    (state_with_attributes(None, condition_true_if_invalid, True),),
+                    (
+                        state_with_attributes(
+                            STATE_UNAVAILABLE, condition_true_if_invalid, True
+                        ),
+                    ),
+                    (
+                        state_with_attributes(
+                            STATE_UNKNOWN, condition_true_if_invalid, True
+                        ),
+                    ),
+                    (
+                        state_with_attributes(other_state, False, False)
+                        for other_state in other_states
+                    ),
+                ),
+            ),
+        ),
+        # Test each target state individually to isolate condition_true expectations
+        *(
+            (
+                condition,
+                condition_options,
+                [
+                    state_with_attributes(other_states[0], False, False),
+                    state_with_attributes(target_state, True, False),
+                ],
+            )
+            for target_state in target_states
+        ),
+    ]
+
+
+def parametrize_condition_states_any(
+    *,
+    condition: str,
+    condition_options: dict[str, Any] | None = None,
+    target_states: list[str | None | tuple[str | None, dict]],
+    other_states: list[str | None | tuple[str | None, dict]],
+    additional_attributes: dict | None = None,
+) -> list[tuple[str, dict[str, Any], list[ConditionStateDescription]]]:
+    """Parametrize states and expected condition evaluations.
+
+    The target_states and other_states iterables are either iterables of
+    states or iterables of (state, attributes) tuples.
+
+    Returns a list of tuples with (condition, condition options, list of states),
+    where states is a list of ConditionStateDescription dicts.
+    """
+
+    return _parametrize_condition_states(
+        condition=condition,
+        condition_options=condition_options,
+        target_states=target_states,
+        other_states=other_states,
+        additional_attributes=additional_attributes,
+        condition_true_if_invalid=False,
+    )
+
+
+def parametrize_condition_states_all(
+    *,
+    condition: str,
+    condition_options: dict[str, Any] | None = None,
+    target_states: list[str | None | tuple[str | None, dict]],
+    other_states: list[str | None | tuple[str | None, dict]],
+    additional_attributes: dict | None = None,
+) -> list[tuple[str, dict[str, Any], list[ConditionStateDescription]]]:
+    """Parametrize states and expected condition evaluations.
+
+    The target_states and other_states iterables are either iterables of
+    states or iterables of (state, attributes) tuples.
+
+    Returns a list of tuples with (condition, condition options, list of states),
+    where states is a list of ConditionStateDescription dicts.
+    """
+
+    return _parametrize_condition_states(
+        condition=condition,
+        condition_options=condition_options,
+        target_states=target_states,
+        other_states=other_states,
+        additional_attributes=additional_attributes,
+        condition_true_if_invalid=True,
+    )
 
 
 def parametrize_trigger_states(
     *,
     trigger: str,
+    trigger_options: dict[str, Any] | None = None,
     target_states: list[str | None | tuple[str | None, dict]],
     other_states: list[str | None | tuple[str | None, dict]],
     additional_attributes: dict | None = None,
     trigger_from_none: bool = True,
     retrigger_on_target_state: bool = False,
-) -> list[tuple[str, list[StateDescription]]]:
+) -> list[tuple[str, dict[str, Any], list[TriggerStateDescription]]]:
     """Parametrize states and expected service call counts.
 
     The target_states and other_states iterables are either iterables of
@@ -189,15 +375,16 @@ def parametrize_trigger_states(
     when the state changes to another target state.
 
     Returns a list of tuples with (trigger, list of states),
-    where states is a list of StateDescription dicts.
+    where states is a list of TriggerStateDescription dicts.
     """
 
     additional_attributes = additional_attributes or {}
+    trigger_options = trigger_options or {}
 
     def state_with_attributes(
         state: str | None | tuple[str | None, dict], count: int
-    ) -> dict:
-        """Return (state, attributes) dict."""
+    ) -> TriggerStateDescription:
+        """Return TriggerStateDescription dict."""
         if isinstance(state, str) or state is None:
             return {
                 "included": {
@@ -226,6 +413,7 @@ def parametrize_trigger_states(
         # Initial state None
         (
             trigger,
+            trigger_options,
             list(
                 itertools.chain.from_iterable(
                     (
@@ -244,6 +432,7 @@ def parametrize_trigger_states(
         # Initial state different from target state
         (
             trigger,
+            trigger_options,
             # other_state,
             list(
                 itertools.chain.from_iterable(
@@ -261,6 +450,7 @@ def parametrize_trigger_states(
         # Initial state same as target state
         (
             trigger,
+            trigger_options,
             list(
                 itertools.chain.from_iterable(
                     (
@@ -280,6 +470,7 @@ def parametrize_trigger_states(
         # Initial state unavailable / unknown
         (
             trigger,
+            trigger_options,
             list(
                 itertools.chain.from_iterable(
                     (
@@ -295,6 +486,7 @@ def parametrize_trigger_states(
         ),
         (
             trigger,
+            trigger_options,
             list(
                 itertools.chain.from_iterable(
                     (
@@ -315,6 +507,7 @@ def parametrize_trigger_states(
         tests.append(
             (
                 trigger,
+                trigger_options,
                 list(
                     itertools.chain.from_iterable(
                         (
@@ -339,10 +532,127 @@ def parametrize_trigger_states(
     return tests
 
 
+def parametrize_numerical_attribute_changed_trigger_states(
+    trigger: str, state: str, attribute: str
+) -> list[tuple[str, dict[str, Any], list[TriggerStateDescription]]]:
+    """Parametrize states and expected service call counts for numerical changed triggers."""
+    return [
+        *parametrize_trigger_states(
+            trigger=trigger,
+            trigger_options={},
+            target_states=[
+                (state, {attribute: 0}),
+                (state, {attribute: 50}),
+                (state, {attribute: 100}),
+            ],
+            other_states=[(state, {attribute: None})],
+            retrigger_on_target_state=True,
+        ),
+        *parametrize_trigger_states(
+            trigger=trigger,
+            trigger_options={CONF_ABOVE: 10},
+            target_states=[
+                (state, {attribute: 50}),
+                (state, {attribute: 100}),
+            ],
+            other_states=[
+                (state, {attribute: None}),
+                (state, {attribute: 0}),
+            ],
+            retrigger_on_target_state=True,
+        ),
+        *parametrize_trigger_states(
+            trigger=trigger,
+            trigger_options={CONF_BELOW: 90},
+            target_states=[
+                (state, {attribute: 0}),
+                (state, {attribute: 50}),
+            ],
+            other_states=[
+                (state, {attribute: None}),
+                (state, {attribute: 100}),
+            ],
+            retrigger_on_target_state=True,
+        ),
+    ]
+
+
+def parametrize_numerical_attribute_crossed_threshold_trigger_states(
+    trigger: str, state: str, attribute: str
+) -> list[tuple[str, dict[str, Any], list[TriggerStateDescription]]]:
+    """Parametrize states and expected service call counts for numerical crossed threshold triggers."""
+    return [
+        *parametrize_trigger_states(
+            trigger=trigger,
+            trigger_options={
+                CONF_THRESHOLD_TYPE: ThresholdType.BETWEEN,
+                CONF_LOWER_LIMIT: 10,
+                CONF_UPPER_LIMIT: 90,
+            },
+            target_states=[
+                (state, {attribute: 50}),
+                (state, {attribute: 60}),
+            ],
+            other_states=[
+                (state, {attribute: None}),
+                (state, {attribute: 0}),
+                (state, {attribute: 100}),
+            ],
+        ),
+        *parametrize_trigger_states(
+            trigger=trigger,
+            trigger_options={
+                CONF_THRESHOLD_TYPE: ThresholdType.OUTSIDE,
+                CONF_LOWER_LIMIT: 10,
+                CONF_UPPER_LIMIT: 90,
+            },
+            target_states=[
+                (state, {attribute: 0}),
+                (state, {attribute: 100}),
+            ],
+            other_states=[
+                (state, {attribute: None}),
+                (state, {attribute: 50}),
+                (state, {attribute: 60}),
+            ],
+        ),
+        *parametrize_trigger_states(
+            trigger=trigger,
+            trigger_options={
+                CONF_THRESHOLD_TYPE: ThresholdType.ABOVE,
+                CONF_LOWER_LIMIT: 10,
+            },
+            target_states=[
+                (state, {attribute: 50}),
+                (state, {attribute: 100}),
+            ],
+            other_states=[
+                (state, {attribute: None}),
+                (state, {attribute: 0}),
+            ],
+        ),
+        *parametrize_trigger_states(
+            trigger=trigger,
+            trigger_options={
+                CONF_THRESHOLD_TYPE: ThresholdType.BELOW,
+                CONF_UPPER_LIMIT: 90,
+            },
+            target_states=[
+                (state, {attribute: 0}),
+                (state, {attribute: 50}),
+            ],
+            other_states=[
+                (state, {attribute: None}),
+                (state, {attribute: 100}),
+            ],
+        ),
+    ]
+
+
 async def arm_trigger(
     hass: HomeAssistant,
     trigger: str,
-    trigger_options: dict | None,
+    trigger_options: dict[str, Any] | None,
     trigger_target: dict,
 ) -> None:
     """Arm the specified trigger, call service test.automation when it triggers."""
@@ -371,10 +681,28 @@ async def arm_trigger(
     )
 
 
+async def create_target_condition(
+    hass: HomeAssistant,
+    *,
+    condition: str,
+    target: dict,
+    behavior: str,
+) -> ConditionCheckerTypeOptional:
+    """Create a target condition."""
+    return await async_condition_from_config(
+        hass,
+        {
+            CONF_CONDITION: condition,
+            CONF_TARGET: target,
+            CONF_OPTIONS: {"behavior": behavior},
+        },
+    )
+
+
 def set_or_remove_state(
     hass: HomeAssistant,
     entity_id: str,
-    state: StateDescription,
+    state: TriggerStateDescription,
 ) -> None:
     """Set or remove the state of an entity."""
     if state["state"] is None:
@@ -397,3 +725,37 @@ def other_states(state: StrEnum | Iterable[StrEnum]) -> list[str]:
         enum_class = list(state)[0].__class__
 
     return sorted({s.value for s in enum_class} - excluded_values)
+
+
+async def assert_condition_gated_by_labs_flag(
+    hass: HomeAssistant, caplog: pytest.LogCaptureFixture, condition: str
+) -> None:
+    """Helper to check that a condition is gated by the labs flag."""
+
+    # Local include to avoid importing the automation component unnecessarily
+    from homeassistant.components import automation  # noqa: PLC0415
+
+    await async_setup_component(
+        hass,
+        automation.DOMAIN,
+        {
+            automation.DOMAIN: {
+                "trigger": {"platform": "event", "event_type": "test_event"},
+                "condition": {
+                    CONF_CONDITION: condition,
+                    CONF_TARGET: {ATTR_LABEL_ID: "test_label"},
+                    CONF_OPTIONS: {"behavior": "any"},
+                },
+                "action": {
+                    "service": "test.automation",
+                },
+            }
+        },
+    )
+
+    assert (
+        "Unnamed automation failed to setup conditions and has been disabled: "
+        f"Condition '{condition}' requires the experimental 'New triggers and "
+        "conditions' feature to be enabled in Home Assistant Labs settings "
+        "(feature flag: 'new_triggers_conditions')"
+    ) in caplog.text

pytest_homeassistant_custom_component/const.py

@@ -5,8 +5,8 @@ This file is originally from homeassistant/core and modified by pytest-homeassis
 """
 from typing import TYPE_CHECKING, Final
 MAJOR_VERSION: Final = 2026
-MINOR_VERSION: Final = 1
-PATCH_VERSION: Final = "2"
+MINOR_VERSION: Final = 2
+PATCH_VERSION: Final = "0b0"
 __short_version__: Final = f"{MAJOR_VERSION}.{MINOR_VERSION}"
 __version__: Final = f"{__short_version__}.{PATCH_VERSION}"
 CONF_API_VERSION: Final = "api_version"

{pytest_homeassistant_custom_component-0.13.307.dist-info → pytest_homeassistant_custom_component-0.13.309.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytest-homeassistant-custom-component
-Version: 0.13.307
+Version: 0.13.309
 Summary: Experimental package to automatically extract test plugins for Home Assistant custom components
 Home-page: https://github.com/MatthewFlamm/pytest-homeassistant-custom-component
 Author: Matthew Flamm
@@ -22,6 +22,7 @@ Requires-Dist: coverage==7.10.6
 Requires-Dist: freezegun==1.5.2
 Requires-Dist: license-expression==30.4.3
 Requires-Dist: mock-open==1.4.0
+Requires-Dist: prek==0.2.28
 Requires-Dist: pydantic==2.12.2
 Requires-Dist: pylint-per-file-ignores==1.4.0
 Requires-Dist: pipdeptree==2.26.1
@@ -41,7 +42,7 @@ Requires-Dist: requests-mock==1.12.1
 Requires-Dist: respx==0.22.0
 Requires-Dist: syrupy==5.0.0
 Requires-Dist: tqdm==4.67.1
-Requires-Dist: homeassistant==2026.1.2
+Requires-Dist: homeassistant==2026.2.0b0
 Requires-Dist: SQLAlchemy==2.0.41
 Requires-Dist: paho-mqtt==2.1.0
 Requires-Dist: numpy==2.3.2
@@ -59,7 +60,7 @@ Dynamic: summary
 
 # pytest-homeassistant-custom-component
 
-![HA core version](https://img.shields.io/static/v1?label=HA+core+version&message=2026.1.2&labelColor=blue)
+![HA core version](https://img.shields.io/static/v1?label=HA+core+version&message=2026.2.0b0&labelColor=blue)
 
 Package to automatically extract testing plugins from Home Assistant for custom component testing.
 The goal is to provide the same functionality as the tests in home-assistant/core.

{pytest_homeassistant_custom_component-0.13.307.dist-info → pytest_homeassistant_custom_component-0.13.309.dist-info}/RECORD

@@ -1,7 +1,7 @@
 pytest_homeassistant_custom_component/__init__.py,sha256=pUI8j-H-57ncCLnvZSDWZPCtJpvi3ACZqPtH5SbedZA,138
 pytest_homeassistant_custom_component/asyncio_legacy.py,sha256=UdkV2mKqeS21QX9LSdBYsBRbm2h4JCVVZeesaOLKOAE,3886
-pytest_homeassistant_custom_component/common.py,sha256=Lgd72s3LB1nMg24w7kswC02SkiqQZ-2InEcIAJTXsig,65510
-pytest_homeassistant_custom_component/const.py,sha256=neoyVk7DEL03QGm8cKjz8Fz-yFchTKCFECJZ0goJWoc,439
+pytest_homeassistant_custom_component/common.py,sha256=1Kwhjp96thdU6X-y8zN-GpRHerz_xmyz_JYd6Xtp3TI,65565
+pytest_homeassistant_custom_component/const.py,sha256=ETxizOD9evHcYSi86bxudFLPIsATd21ykClJlqoVniQ,441
 pytest_homeassistant_custom_component/ignore_uncaught_exceptions.py,sha256=zM7gPOjojoh_c9bk9ln9zfrVquYz8GroR1a-Hn3qkVA,1646
 pytest_homeassistant_custom_component/patch_json.py,sha256=hNUeb1yxAr7ONfvX-o_WkI6zhQDCdKl7GglPjkVUiHo,1063
 pytest_homeassistant_custom_component/patch_recorder.py,sha256=lW8N_3ZIKQ5lsVjRc-ROo7d0egUZcpjquWKqe7iEF94,819
@@ -9,7 +9,7 @@ pytest_homeassistant_custom_component/patch_time.py,sha256=jdnOAXDxUA0AKqvyeSrRC
 pytest_homeassistant_custom_component/plugins.py,sha256=ZZlTVoPEJMqTiyJcVrxJaykxG4G6Ij_3_Jb-ANGj6Hw,70117
 pytest_homeassistant_custom_component/syrupy.py,sha256=N_g_90dWqruzUogQi0rJsuN0XRbA6ffJen62r8P9cdo,15588
 pytest_homeassistant_custom_component/typing.py,sha256=6Qr1lDzFwCCYZzvgXsnJDJcRXksojQPNn87NPc7YTeE,1739
-pytest_homeassistant_custom_component/components/__init__.py,sha256=0hecbqyD4TaYh_FHKpP0O5XSmIuJFgzwDw8ZFtPgjzc,13275
+pytest_homeassistant_custom_component/components/__init__.py,sha256=pzGuZ-P4gebfb2R8MxHlFJzRwHIoNlgit1psadQG8JU,25664
 pytest_homeassistant_custom_component/components/diagnostics/__init__.py,sha256=O_ys8t0iHvRorFr4TrR9k3sa3Xh5qBb4HsylY775UFA,2431
 pytest_homeassistant_custom_component/components/recorder/__init__.py,sha256=ugrLzvjSQFSmYRjy88ZZSiyA-NLgKlLkFp0OKguy6a4,225
 pytest_homeassistant_custom_component/components/recorder/common.py,sha256=_o0TjbqHCJ67U2prFqySO0vxx_oIn2RsKxFxNPitTfQ,22097
@@ -19,10 +19,10 @@ pytest_homeassistant_custom_component/test_util/aiohttp.py,sha256=sJHmGf4Oig0SUM
 pytest_homeassistant_custom_component/testing_config/__init__.py,sha256=SRp6h9HJi2I_vA6cPNkMiR0BTYib5XVmL03H-l3BPL0,158
 pytest_homeassistant_custom_component/testing_config/custom_components/__init__.py,sha256=-l6KCBLhwEDkCztlY6S-j53CjmKY6-A_3eX5JVS02NY,173
 pytest_homeassistant_custom_component/testing_config/custom_components/test_constant_deprecation/__init__.py,sha256=2vF_C-VP9tDjZMX7h6iJRAugtH2Bf3b4fE3i9j4vGeY,383
-pytest_homeassistant_custom_component-0.13.307.dist-info/licenses/LICENSE,sha256=7h-vqUxyeQNXiQgRJ8350CSHOy55M07DZuv4KG70AS8,1070
-pytest_homeassistant_custom_component-0.13.307.dist-info/licenses/LICENSE_HA_CORE.md,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-pytest_homeassistant_custom_component-0.13.307.dist-info/METADATA,sha256=m0fwCvgB1279Oq_cJVYKEX8yI_AAcf-ULFji6bDiDNg,5736
-pytest_homeassistant_custom_component-0.13.307.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pytest_homeassistant_custom_component-0.13.307.dist-info/entry_points.txt,sha256=bOCTSuP8RSPg0QfwdfurUShvMGWg4MI2F8rxbWx-VtQ,73
-pytest_homeassistant_custom_component-0.13.307.dist-info/top_level.txt,sha256=PR2cize2la22eOO7dQChJWK8dkJnuMmDC-fhafmdOWw,38
-pytest_homeassistant_custom_component-0.13.307.dist-info/RECORD,,
+pytest_homeassistant_custom_component-0.13.309.dist-info/licenses/LICENSE,sha256=7h-vqUxyeQNXiQgRJ8350CSHOy55M07DZuv4KG70AS8,1070
+pytest_homeassistant_custom_component-0.13.309.dist-info/licenses/LICENSE_HA_CORE.md,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+pytest_homeassistant_custom_component-0.13.309.dist-info/METADATA,sha256=Xt8k-0dpn4epLXnQAwb5Kl3PnT128nnnrYqJAZs5lww,5768
+pytest_homeassistant_custom_component-0.13.309.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+pytest_homeassistant_custom_component-0.13.309.dist-info/entry_points.txt,sha256=bOCTSuP8RSPg0QfwdfurUShvMGWg4MI2F8rxbWx-VtQ,73
+pytest_homeassistant_custom_component-0.13.309.dist-info/top_level.txt,sha256=PR2cize2la22eOO7dQChJWK8dkJnuMmDC-fhafmdOWw,38
+pytest_homeassistant_custom_component-0.13.309.dist-info/RECORD,,

{pytest_homeassistant_custom_component-0.13.307.dist-info → pytest_homeassistant_custom_component-0.13.309.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any