Products API Reference¶

@dataclass
class ProductInfo:
    pid: int                              # Product ID
    name: str                             # Product name (e.g., "LIFX (A19)")
    vendor: int                           # Vendor ID (always 1 for LIFX)
    capabilities: int                     # Bitfield of capabilities
    temperature_range: TemperatureRange | None  # Min/max Kelvin
    min_ext_mz_firmware: int | None       # Min firmware for extended multizone

from lifx_emulator.products import get_product, ProductCapability

product = get_product(32)  # LIFX Z
if product.has_capability(ProductCapability.MULTIZONE):
    print(f"{product.name} supports multizone")

from lifx_emulator.products import get_product

product = get_product(55)  # LIFX Tile
print(f"Color: {product.has_color}")         # True
print(f"Matrix: {product.has_matrix}")       # True
print(f"Multizone: {product.has_multizone}") # False

from lifx_emulator.products import get_product

product = get_product(38)  # LIFX Beam
if product.supports_extended_multizone():
    print("Supports extended multizone messages")

class ProductCapability(IntEnum):
    COLOR = 1               # Full RGB color
    INFRARED = 2            # Night vision IR
    MULTIZONE = 4           # Linear zones (strips)
    CHAIN = 8               # Device chaining
    MATRIX = 16             # 2D tile grid
    RELAYS = 32             # Relay switches
    BUTTONS = 64            # Physical buttons
    HEV = 128               # Germicidal light
    EXTENDED_MULTIZONE = 256  # Extended multizone protocol

from lifx_emulator.products import ProductCapability

# Check multiple capabilities
capabilities = ProductCapability.COLOR | ProductCapability.INFRARED
has_color = bool(capabilities & ProductCapability.COLOR)        # True
has_multizone = bool(capabilities & ProductCapability.MULTIZONE) # False

from lifx_emulator.products import get_product

product = get_product(27)  # LIFX (A19)
if product and product.temperature_range:
    print(f"Product: {product.name}")
    print(f"Capabilities: {product.capabilities}")
    print(f"Temperature range: {product.temperature_range.min}-{product.temperature_range.max}K")

from lifx_emulator.products import get_registry
from lifx_emulator.products.registry import PRODUCTS

registry = get_registry()
print(f"Total products: {len(registry)}")
print(f"Has LIFX Z: {32 in registry}")

for pid, product in PRODUCTS.items():
    if product.has_multizone:
        print(f"{pid}: {product.name}")

from lifx_emulator.products import get_device_class_name

class_name = get_device_class_name(32)
print(f"Device class: {class_name}")  # "MultiZoneLight"

from lifx_emulator.products.specs import get_specs

# LIFX Z
specs = get_specs(32)
print(f"Zones: {specs.default_zone_count}")  # 16

# LIFX Beam
specs = get_specs(38)
print(f"Zones: {specs.default_zone_count}")  # 80

# LIFX Tile
specs = get_specs(55)
print(f"Tiles: {specs.default_tile_count}")  # 5
print(f"Dimensions: {specs.tile_width}x{specs.tile_height}")  # 8x8

from lifx_emulator.products.registry import PRODUCTS

# Find all multizone products
multizone_products = [
    product for product in PRODUCTS.values()
    if product.has_multizone
]

for product in multizone_products:
    print(f"{product.pid}: {product.name}")
# Output: 32: LIFX Z, 38: LIFX Beam, 141: LIFX Neon, etc.

from lifx_emulator.products.registry import PRODUCTS

# Find all color + infrared products
color_ir_products = [
    product for product in PRODUCTS.values()
    if product.has_color and product.has_infrared
]

for product in color_ir_products:
    print(f"{product.pid}: {product.name}")
# Output: 25: LIFX+ (A19), 26: LIFX+ (BR30), 29: LIFX+ (A19), etc.

from lifx_emulator.products.registry import PRODUCTS

# Find products that support warm white (< 3000K)
warm_white_products = [
    product for product in PRODUCTS.values()
    if product.temperature_range and product.temperature_range.min < 3000
]

for product in warm_white_products:
    print(f"{product.pid}: {product.name} ({product.temperature_range.min}K)")

from lifx_emulator.products.registry import PRODUCTS

# Find extended multizone products
extended_mz_products = [
    product for product in PRODUCTS.values()
    if product.has_extended_multizone
]

for product in extended_mz_products:
    print(f"{product.pid}: {product.name}")
# Output: 32: LIFX Z, 38: LIFX Beam, etc.

from lifx_emulator.products import ProductInfo
from lifx_emulator.products.registry import PRODUCTS


def filter_products(
    color: bool = False,
    multizone: bool = False,
    matrix: bool = False,
    hev: bool = False,
) -> list[ProductInfo]:
    """Filter products by capabilities."""
    results = []

    for product in PRODUCTS.values():
        if color and not product.has_color:
            continue
        if multizone and not product.has_multizone:
            continue
        if matrix and not product.has_matrix:
            continue
        if hev and not product.has_hev:
            continue
        results.append(product)

    return results

# Usage
matrix_products = filter_products(matrix=True)
color_multizone = filter_products(color=True, multizone=True)

from lifx_emulator.factories import create_device
from lifx_emulator.products import get_product

# Create device by product ID
device = create_device(product_id=27)  # LIFX (A19)

# Get product info
product = get_product(27)
print(f"Created: {product.name}")
print(f"Color: {device.state.has_color}")
print(f"Multizone: {device.state.has_multizone}")

from lifx_emulator.factories import create_device
from lifx_emulator.products.specs import get_specs

# Create LIFX Z with product defaults
device = create_device(product_id=32)

# Specs are automatically applied
specs = get_specs(32)
assert device.state.zone_count == specs.default_zone_count  # 16 zones

# Override defaults
device = create_device(product_id=32, zone_count=8)  # Custom: 8 zones

from lifx_emulator.products.registry import PRODUCTS

def list_products(filter_capability: str | None = None):
    """List all products with optional capability filter."""
    for pid, product in sorted(PRODUCTS.items()):
        # Apply filter
        if filter_capability == "multizone" and not product.has_multizone:
            continue
        if filter_capability == "matrix" and not product.has_matrix:
            continue
        if filter_capability == "hev" and not product.has_hev:
            continue

        # Print product info
        capabilities = []
        if product.has_color:
            capabilities.append("color")
        if product.has_infrared:
            capabilities.append("infrared")
        if product.has_multizone:
            capabilities.append("multizone")
        if product.has_extended_multizone:
            capabilities.append("extended-mz")
        if product.has_matrix:
            capabilities.append("matrix")
        if product.has_hev:
            capabilities.append("HEV")

        print(f"{pid:3d}  {product.name:40s}  {', '.join(capabilities)}")

# Usage
list_products()
list_products(filter_capability="matrix")