redfish-python-sdk 1.0.0__py3-none-any.whl

redfish_sdk/models/managers.py

@@ -0,0 +1,153 @@
+"""
+Manager (BMC) resource models.
+
+"""
+from __future__ import annotations
+
+from typing import List, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from .common import Entity, Link, Status
+
+
+class CommandShell(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+    connect_types_supported: Optional[List[str]] = Field(None, alias="ConnectTypesSupported")
+    max_concurrent_sessions: Optional[int] = Field(None, alias="MaxConcurrentSessions")
+    service_enabled: Optional[bool] = Field(None, alias="ServiceEnabled")
+
+
+class GraphicalConsole(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+    connect_types_supported: Optional[List[str]] = Field(None, alias="ConnectTypesSupported")
+    max_concurrent_sessions: Optional[int] = Field(None, alias="MaxConcurrentSessions")
+    service_enabled: Optional[bool] = Field(None, alias="ServiceEnabled")
+
+
+class SerialConsole(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+    connect_types_supported: Optional[List[str]] = Field(None, alias="ConnectTypesSupported")
+    max_concurrent_sessions: Optional[int] = Field(None, alias="MaxConcurrentSessions")
+    service_enabled: Optional[bool] = Field(None, alias="ServiceEnabled")
+
+
+class Manager(Entity):
+    """
+    Represents a BMC (Baseboard Management Controller) manager.
+    Endpoint: /redfish/v1/Managers/{managerId}
+
+    """
+    date_time: Optional[str] = Field(None, alias="DateTime")
+    date_time_local_offset: Optional[str] = Field(None, alias="DateTimeLocalOffset")
+    command_shell: Optional[CommandShell] = Field(None, alias="CommandShell")
+    graphical_console: Optional[GraphicalConsole] = Field(None, alias="GraphicalConsole")
+    serial_console: Optional[SerialConsole] = Field(None, alias="SerialConsole")
+    dedicated_network_ports: Optional[Link] = Field(None, alias="DedicatedNetworkPorts")
+    ethernet_interfaces: Optional[Link] = Field(None, alias="EthernetInterfaces")
+    firmware_version: Optional[str] = Field(None, alias="FirmwareVersion")
+    host_interfaces: Optional[Link] = Field(None, alias="HostInterfaces")
+    log_services: Optional[Link] = Field(None, alias="LogServices")
+    manager_type: Optional[str] = Field(None, alias="ManagerType")
+    model: Optional[str] = Field(None, alias="Model")
+    network_protocol: Optional[Link] = Field(None, alias="NetworkProtocol")
+    power_state: Optional[str] = Field(None, alias="PowerState")
+    security_policy: Optional[Link] = Field(None, alias="SecurityPolicy")
+    serial_interfaces: Optional[Link] = Field(None, alias="SerialInterfaces")
+    service_entry_point_uuid: Optional[str] = Field(None, alias="ServiceEntryPointUUID")
+    status: Optional[Status] = Field(None, alias="Status")
+    uuid: Optional[str] = Field(None, alias="UUID")
+
+
+# ---------------------------------------------------------------------------
+# NetworkProtocol
+# ---------------------------------------------------------------------------
+
+class ProtocolConfig(BaseModel):
+    """Generic protocol configuration (SSH, HTTPS, IPMI, etc.)."""
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+    port: Optional[int] = Field(None, alias="Port")
+    protocol_enabled: Optional[bool] = Field(None, alias="ProtocolEnabled")
+
+
+class NetworkProtocol(Entity):
+    """
+    Network protocol configuration for a manager (BMC).
+    Endpoint: /redfish/v1/Managers/{managerId}/NetworkProtocol
+
+    """
+    fqdn: Optional[str] = Field(None, alias="FQDN")
+    host_name: Optional[str] = Field(None, alias="HostName")
+    http: Optional[ProtocolConfig] = Field(None, alias="HTTP")
+    https: Optional[ProtocolConfig] = Field(None, alias="HTTPS")
+    ipmi: Optional[ProtocolConfig] = Field(None, alias="IPMI")
+    ssh: Optional[ProtocolConfig] = Field(None, alias="SSH")
+    snmp: Optional[ProtocolConfig] = Field(None, alias="SNMP")
+    virtual_media: Optional[ProtocolConfig] = Field(None, alias="VirtualMedia")
+    kvmip: Optional[ProtocolConfig] = Field(None, alias="KVMIP")
+    status: Optional[Status] = Field(None, alias="Status")
+
+
+# ---------------------------------------------------------------------------
+# EthernetInterface
+# ---------------------------------------------------------------------------
+
+class IPv4Address(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+    address: Optional[str] = Field(None, alias="Address")
+    address_origin: Optional[str] = Field(None, alias="AddressOrigin")
+    gateway: Optional[str] = Field(None, alias="Gateway")
+    subnet_mask: Optional[str] = Field(None, alias="SubnetMask")
+
+
+class IPv6Address(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+    address: Optional[str] = Field(None, alias="Address")
+    address_origin: Optional[str] = Field(None, alias="AddressOrigin")
+    address_state: Optional[str] = Field(None, alias="AddressState")
+    prefix_length: Optional[int] = Field(None, alias="PrefixLength")
+
+
+class Vlan(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+    vlan_id: Optional[int] = Field(None, alias="VLANId")
+    vlan_enable: Optional[bool] = Field(None, alias="VLANEnable")
+
+
+class EthernetInterface(Entity):
+    """
+    Represents a BMC Ethernet interface.
+    Endpoint: /redfish/v1/Managers/{managerId}/EthernetInterfaces/{id}
+
+    """
+    auto_neg: Optional[bool] = Field(None, alias="AutoNeg")
+    fqdn: Optional[str] = Field(None, alias="FQDN")
+    full_duplex: Optional[bool] = Field(None, alias="FullDuplex")
+    host_name: Optional[str] = Field(None, alias="HostName")
+    ipv4_addresses: Optional[List[IPv4Address]] = Field(None, alias="IPv4Addresses")
+    ipv6_addresses: Optional[List[IPv6Address]] = Field(None, alias="IPv6Addresses")
+    ipv6_default_gateway: Optional[str] = Field(None, alias="IPv6DefaultGateway")
+    interface_enabled: Optional[bool] = Field(None, alias="InterfaceEnabled")
+    link_status: Optional[str] = Field(None, alias="LinkStatus")
+    mac_address: Optional[str] = Field(None, alias="MACAddress")
+    mtu_size: Optional[int] = Field(None, alias="MTUSize")
+    name_servers: Optional[List[str]] = Field(None, alias="NameServers")
+    permanent_mac_address: Optional[str] = Field(None, alias="PermanentMACAddress")
+    speed_mbps: Optional[int] = Field(None, alias="SpeedMbps")
+    vlan: Optional[Vlan] = Field(None, alias="VLAN")
+    status: Optional[Status] = Field(None, alias="Status")
+
+
+# ---------------------------------------------------------------------------
+# HostInterface
+# ---------------------------------------------------------------------------
+
+class HostInterface(Entity):
+    """
+    Represents a host interface for BMC-to-host communication.
+    Endpoint: /redfish/v1/Managers/{managerId}/HostInterfaces/{id}
+    """
+    host_interface_type: Optional[str] = Field(None, alias="HostInterfaceType")
+    interface_enabled: Optional[bool] = Field(None, alias="InterfaceEnabled")
+    network_protocol: Optional[Link] = Field(None, alias="NetworkProtocol")
+    status: Optional[Status] = Field(None, alias="Status")

redfish_sdk/models/memory.py

@@ -0,0 +1,50 @@
+"""
+Memory (DIMM) component models.
+
+"""
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from pydantic import BaseModel, ConfigDict
+
+from .check import Field
+from .common import Entity, Link, Status
+from .oem import Oem
+
+
+class MemoryLocation(BaseModel):
+    """Physical location info for a memory module."""
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    channel: Optional[Any] = Field(None, alias="Channel")
+    memory_controller: Optional[int] = Field(None, alias="MemoryController")
+    slot: Optional[int] = Field(None, alias="Slot")
+    socket: Optional[int] = Field(None, alias="Socket")
+
+
+class Memory(Entity):
+    """
+    Represents a memory module (DIMM).
+    Endpoint: /redfish/v1/Systems/{systemId}/Memory/{memoryId}
+
+    """
+    base_module_type: Optional[str] = Field(None, alias="BaseModuleType")
+    bus_width_bits: Optional[int] = Field(None, alias="BusWidthBits")
+    capacity_mib: Optional[int] = Field(None, alias="CapacityMiB", validate="required,type=int,gt=0")
+    data_width_bits: Optional[int] = Field(None, alias="DataWidthBits")
+    operating_speed_mhz: Optional[int] = Field(None, alias="OperatingSpeedMhz", validate="type=int,gt=0")
+    manufacturer: Optional[str] = Field(None, alias="Manufacturer", validate="type=str")
+    vendor_id: Optional[str] = Field(None, alias="VendorID")
+    part_number: Optional[str] = Field(None, alias="PartNumber", validate="type=str")
+    serial_number: Optional[str] = Field(None, alias="SerialNumber", validate="type=str")
+    device_locator: Optional[str] = Field(None, alias="DeviceLocator")
+    device_id: Optional[str] = Field(None, alias="DeviceID")
+    error_correction: Optional[str] = Field(None, alias="ErrorCorrection")
+    memory_device_type: Optional[str] = Field(None, alias="MemoryDeviceType", validate="type=str")
+    memory_type: Optional[str] = Field(None, alias="MemoryType")
+    rank_count: Optional[int] = Field(None, alias="RankCount")
+    memory_location: Optional[MemoryLocation] = Field(None, alias="MemoryLocation")
+    status: Optional[Status] = Field(None, alias="Status", validate="status")
+    oem: Optional[Oem] = Field(None, alias="Oem")
+    environment_metrics: Optional[Link] = Field(None, alias="EnvironmentMetrics")

redfish_sdk/models/network_adapter.py

@@ -0,0 +1,76 @@
+"""
+Network Adapter (NIC) component models.
+
+"""
+from __future__ import annotations
+
+from typing import List, Optional
+
+from pydantic import BaseModel, ConfigDict
+
+from .check import Field
+from .common import Entity, Link, Status
+from .oem import Oem
+
+
+class DataCenterBridging(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+    capable: Optional[bool] = Field(None, alias="Capable")
+
+
+class NPAR(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+    npar_capable: Optional[bool] = Field(None, alias="NparCapable")
+    npar_enabled: Optional[bool] = Field(None, alias="NparEnabled")
+
+
+class VirtualFunction(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+    device_max_count: Optional[int] = Field(None, alias="DeviceMaxCount")
+    min_assignment_group_size: Optional[int] = Field(None, alias="MinAssignmentGroupSize")
+    network_port_max_count: Optional[int] = Field(None, alias="NetworkPortMaxCount")
+
+
+class VirtualizationOffload(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+    virtual_function: Optional[VirtualFunction] = Field(None, alias="VirtualFunction")
+
+
+class ControllerCapabilities(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+    data_center_bridging: Optional[DataCenterBridging] = Field(None, alias="DataCenterBridging")
+    npar: Optional[NPAR] = Field(None, alias="NPAR")
+    network_device_function_count: Optional[int] = Field(
+        None, alias="NetworkDeviceFunctionCount"
+    )
+    network_port_count: Optional[int] = Field(None, alias="NetworkPortCount")
+    virtualization_offload: Optional[VirtualizationOffload] = Field(
+        None, alias="VirtualizationOffload"
+    )
+
+
+class Controller(BaseModel):
+    """Embedded NIC controller within a NetworkAdapter."""
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+    controller_capabilities: Optional[ControllerCapabilities] = Field(
+        None, alias="ControllerCapabilities"
+    )
+    firmware_package_version: Optional[str] = Field(None, alias="FirmwarePackageVersion")
+
+
+class NetworkAdapter(Entity):
+    """
+    Represents a network adapter (NIC).
+    Endpoint: /redfish/v1/Chassis/{chassisId}/NetworkAdapters/{networkAdapterId}
+
+    """
+    controllers: Optional[List[Controller]] = Field(None, alias="Controllers", validate="list")
+    manufacturer: Optional[str] = Field(None, alias="Manufacturer", validate="type=str")
+    model: Optional[str] = Field(None, alias="Model", validate="type=str")
+    network_device_functions: Optional[Link] = Field(None, alias="NetworkDeviceFunctions")
+    part_number: Optional[str] = Field(None, alias="PartNumber")
+    ports: Optional[Link] = Field(None, alias="Ports")
+    sku: Optional[str] = Field(None, alias="SKU")
+    serial_number: Optional[str] = Field(None, alias="SerialNumber", validate="type=str")
+    status: Optional[Status] = Field(None, alias="Status", validate="status")
+    oem: Optional[Oem] = Field(None, alias="Oem")

redfish_sdk/models/oem.py

@@ -0,0 +1,173 @@
+"""
+OEM (vendor-specific) data models.
+
+Redfish allows vendors to extend standard resources with OEM fields.
+This module models the common OEM fields used across Dell, HPE, xFusion,
+Lenovo, Inspur (浪潮), Ningchang (宁畅), etc.
+
+"""
+from __future__ import annotations
+
+from typing import Any, List, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from .common import Entity, Link
+
+
+class MainBoard(Entity):
+    """
+    Mainboard (motherboard) FRU information.
+    Field aliases support multiple vendor naming conventions.
+
+    Inherits from Entity so that when parsed from a standalone FRU
+    resource endpoint (e.g. ``/redfish/v1/Chassis/1/FruService/0``),
+    standard fields like ``@odata.id``, ``Id``, ``Name`` are preserved.
+    """
+
+    chassis_part_number: Optional[str] = Field(None, alias="ChassisPartNumber")
+    part_number: Optional[str] = Field(None, alias="PartNumber")
+    product_name: Optional[str] = Field(None, alias="ProductName")
+    serial_number: Optional[str] = Field(None, alias="SerialNumber")
+    manufacturer: Optional[str] = Field(None, alias="Manufacturer")
+    build_date: Optional[str] = Field(None, alias="BuildDate,ManufactureDate")
+    pretty_name: Optional[str] = Field(None, alias="PrettyName")
+
+
+class DeviceMaxNum(BaseModel):
+    """Maximum number of each hardware component type."""
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    memory_num: Optional[int] = Field(None, alias="MemoryNum")
+    pcie_num: Optional[int] = Field(None, alias="PCIeNum")
+    cpu_num: Optional[int] = Field(None, alias="CPUNum")
+    disk_num: Optional[int] = Field(None, alias="DiskNum")
+    power_supply_num: Optional[int] = Field(None, alias="PowerSupplyNum")
+    fan_num: Optional[int] = Field(None, alias="FanNum")
+
+
+class Bmc(BaseModel):
+    """
+    BMC (Baseboard Management Controller) OEM extension fields.
+
+    This is a catch-all model for OEM-specific fields from various vendors.
+    Due to the wide variety of vendor implementations, most fields are optional.
+
+    Key fields:
+    - fru: Link to FRU data (华为 xFusion, 联想 etc.)
+    - mainboard: Mainboard info (华为 iBMC)
+    - bmc_version, cpld_version: Firmware version info
+    """
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    # Product info
+    product_name: Optional[str] = Field(None, alias="ProductName")
+    bios_vendor: Optional[str] = Field(None, alias="BiosVendor")
+
+    # Memory OEM (H3C)
+    technology: Optional[str] = Field(None, alias="Technology")
+
+    # Memory OEM (Ningchang 宁畅)
+    mem_type: Optional[str] = Field(None, alias="Type")
+    rank: Optional[str] = Field(None, alias="Rank")
+
+    # NetworkAdapter OEM (Ningchang)
+    name: Optional[str] = Field(None, alias="Name")
+    driver_name: Optional[str] = Field(None, alias="DriverName")
+    driver_version: Optional[str] = Field(None, alias="DriverVersion")
+    card_manufacturer: Optional[str] = Field(None, alias="CardManufacturer")
+    board_manufacturer: Optional[str] = Field(None, alias="BoardManufacturer")
+    card_model: Optional[str] = Field(None, alias="CardModel")
+    device_locator: Optional[str] = Field(None, alias="DeviceLocator")
+    position: Optional[str] = Field(None, alias="Position")
+    root_bdf: Optional[str] = Field(None, alias="RootBDF")
+
+    # Chassis OEM
+    mainboard: Optional[MainBoard] = Field(None, alias="Mainboard")
+    device_max_num: Optional[DeviceMaxNum] = Field(None, alias="DeviceMaxNum")
+    power_button_enabled: Optional[bool] = Field(None, alias="PowerButtonEnabled")
+
+    # 浪潮 (Inspur) specific
+    threshold_sensors: Optional[Link] = Field(None, alias="ThresholdSensors")
+    discrete_sensors: Optional[Link] = Field(None, alias="DiscreteSensors")
+    boards: Optional[Link] = Field(None, alias="Boards")
+    backplanes: Optional[Link] = Field(None, alias="Backplanes")
+    health_summary: Optional[Link] = Field(None, alias="HealthSummary")
+
+    # Drive OEM (Inspur)
+    rebuild_led: Optional[str] = Field(None, alias="RebuildLED")
+    interface_type: Optional[str] = Field(None, alias="Interface")
+
+    # Thermal OEM
+    fan_speed_adjustment_mode: Optional[str] = Field(None, alias="FanSpeedAdjustmentMode")
+    fan_speed_level_percents: Optional[int] = Field(None, alias="FanSpeedLevelPercents")
+
+    # Power OEM
+    line_output_voltage: Optional[float] = Field(None, alias="LineOutputVoltage")
+    fan_speed: Optional[int] = Field(None, alias="FANSpeed")
+    heatsink_temperature_celsius: Optional[float] = Field(None, alias="HeatsinkTemperatureCelsius")
+    ambient_temperature_celsius: Optional[float] = Field(None, alias="AmbientTemperatureCelsius")
+    total_power: Optional[int] = Field(None, alias="TotalPower")
+
+    # System OEM
+    configuration_model: Optional[str] = Field(None, alias="ConfigurationModel")
+    bmc_version: Optional[str] = Field(None, alias="BMCVersion")
+    cpld_version: Optional[str] = Field(None, alias="CPLDVersion")
+    me_version: Optional[str] = Field(None, alias="MEVersion")
+    psu_version: Optional[str] = Field(None, alias="PSUVersion")
+    cpu_usage_percent: Optional[int] = Field(None, alias="CPUUsagePercent")
+    memory_usage_percent: Optional[int] = Field(None, alias="MemoryUsagePercent")
+
+    # FRU link (xFusion, Lenovo 等)
+    fru: Optional[Link] = Field(None, alias="Fru")
+    kvm: Optional[Link] = Field(None, alias="KVM")
+
+    # Processor OEM
+    current_speed_mhz: Optional[int] = Field(None, alias="CurrentSpeedMHz")
+    l1_cache_kib: Optional[int] = Field(None, alias="L1CacheKiB")
+    l2_cache_kib: Optional[int] = Field(None, alias="L2CacheKiB")
+    l3_cache_kib: Optional[int] = Field(None, alias="L3CacheKiB")
+
+    # Auth
+    x_auth_token: Optional[str] = Field(None, alias="X-Auth-Token")
+    serial_number: Optional[str] = Field(None, alias="SerialNumber")
+    part_number: Optional[str] = Field(None, alias="PartNumber")
+
+    # Lenovo
+    system_board_serial_number: Optional[str] = Field(None, alias="SystemBoardSerialNumber")
+    fru_part_number: Optional[str] = Field(None, alias="FruPartNumber")
+
+
+class Oem(BaseModel):
+    """
+    Top-level OEM wrapper used in most Redfish resources.
+
+    The 'bmc' field accepts multiple vendor-specific keys:
+    - Public (华为 iBMC / xFusion)
+    - BMC
+    - xFusion
+    - Lenovo
+
+    """
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    # The SDK resolves vendor-specific OEM keys at parse time
+    bmc: Optional[Bmc] = Field(None, alias="Public")
+    host_post_code: Optional[List[Link]] = Field(None, alias="HostPostCode")
+    fru_service: Optional[str] = Field(None, alias="FruService")
+
+    def model_post_init(self, __context: Any) -> None:
+        """
+        After initialization, resolve vendor-specific OEM keys into the 'bmc' field.
+        This replicates Java's @JsonAlias behavior for multi-vendor support.
+        """
+        if self.bmc is None:
+            extra = self.model_extra or {}
+            for key in ("BMC", "xFusion", "Lenovo", "Hpe", "Dell"):
+                if key in extra and extra[key] is not None:
+                    val = extra[key]
+                    if isinstance(val, dict):
+                        self.bmc = Bmc.model_validate(val)
+                    elif isinstance(val, Bmc):
+                        self.bmc = val
+                    break

redfish_sdk/models/pcie_device.py

@@ -0,0 +1,89 @@
+"""
+PCIe Device component models.
+
+"""
+from __future__ import annotations
+
+from typing import List, Optional
+
+from pydantic import BaseModel, ConfigDict
+
+from .check import Field
+from .common import Entity, Link, Status
+
+
+class PCIeInterface(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+    lanes_in_use: Optional[int] = Field(None, alias="LanesInUse")
+    max_lanes: Optional[int] = Field(None, alias="MaxLanes")
+    max_pcie_type: Optional[str] = Field(None, alias="MaxPCIeType")
+    pcie_type: Optional[str] = Field(None, alias="PCIeType")
+
+
+class GpuCore(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+    build_time: Optional[str] = Field(None, alias="BuildTime")
+    capacity_gb: Optional[int] = Field(None, alias="CapacityGB")
+    member_id: Optional[int] = Field(None, alias="MemberId")
+    power: Optional[float] = Field(None, alias="Power")
+    temperature: Optional[int] = Field(None, alias="Temperature")
+
+
+class GpuPerformanceParameters(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+    encoder_usage_percent: Optional[str] = Field(None, alias="EncoderUsagePercent")
+    decoder_usage_percent: Optional[str] = Field(None, alias="DecoderUsagePercent")
+    gpu_usage_percent: Optional[str] = Field(None, alias="GPUUsagePercent")
+    temperature_celsius: Optional[str] = Field(None, alias="TemperatureCelsius")
+    power_watts: Optional[str] = Field(None, alias="PowerWatts")
+
+
+class PCIeDeviceOEMPublic(BaseModel):
+    """OEM public extension for PCIe GPU devices (华为 xFusion specific)."""
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+    device_bdf: Optional[str] = Field(None, alias="DeviceBDF")
+    device_locator: Optional[str] = Field(None, alias="DeviceLocator")
+    memory_size_mib: Optional[int] = Field(None, alias="MemorySizeMiB")
+    gpu_core: Optional[List[GpuCore]] = Field(None, alias="GpuCore")
+    gpu_performance_parameters: Optional[GpuPerformanceParameters] = Field(
+        None, alias="GpuPerformanceParameters"
+    )
+    memory_band_width: Optional[str] = Field(None, alias="MemoryBandWidth")
+    reading_celsius: Optional[int] = Field(None, alias="ReadingCelsius")
+    link_speed: Optional[str] = Field(None, alias="LinkSpeed")
+    max_link_speed: Optional[str] = Field(None, alias="MaxLinkSpeed")
+    link_width: Optional[int] = Field(None, alias="LinkWidth")
+    max_link_width: Optional[int] = Field(None, alias="MaxLinkWidth")
+    pcie_card_type: Optional[str] = Field(None, alias="PCIeCardType")
+    power_capacity_watts: Optional[int] = Field(None, alias="PowerCapacityWatts")
+    power_watts: Optional[float] = Field(None, alias="PowerWatts")
+    power_consumed_watts: Optional[float] = Field(None, alias="PowerConsumedWatts")
+    slot_number: Optional[int] = Field(None, alias="SlotNumber")
+
+
+class PCIeDeviceOEM(BaseModel):
+    """OEM wrapper for PCIe device."""
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+    gpu_oem_public: Optional[PCIeDeviceOEMPublic] = Field(None, alias="Public")
+
+
+class PCIeDevice(Entity):
+    """
+    Represents a PCIe device (GPU, NIC, etc.).
+    Endpoint: /redfish/v1/Chassis/{chassisId}/PCIeDevices/{pcieDeviceId}
+
+    The 'name' field is used to identify GPU devices (contains "GPU" substring).
+    OEM field contains extended GPU metrics for 华为 xFusion servers.
+
+    """
+    card_model: Optional[str] = Field(None, alias="CardModel")
+    pcie_functions: Optional[Link] = Field(None, alias="PCIeFunctions")
+    pcie_interface: Optional[PCIeInterface] = Field(None, alias="PCIeInterface")
+    oem: Optional[PCIeDeviceOEM] = Field(None, alias="Oem")
+    staged_version: Optional[str] = Field(None, alias="StagedVersion")
+    status: Optional[Status] = Field(None, alias="Status", validate="status")
+    model: Optional[str] = Field(None, alias="Model", validate="type=str")
+    manufacturer: Optional[str] = Field(None, alias="Manufacturer", validate="type=str")
+    serial_number: Optional[str] = Field(None, alias="SerialNumber")
+    part_number: Optional[str] = Field(None, alias="PartNumber")
+    firmware_version: Optional[str] = Field(None, alias="FirmwareVersion", validate="type=str")

redfish_sdk/models/power.py

@@ -0,0 +1,92 @@
+"""
+Power component models (PSU, voltage, power control).
+
+"""
+from __future__ import annotations
+
+from typing import List, Optional
+
+from pydantic import BaseModel, ConfigDict
+
+from .check import Field
+from .common import Entity, Link, Status
+from .oem import Oem
+from .thermal import Redundancy
+
+
+class InputRange(BaseModel):
+    """Input voltage range for a power supply."""
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    input_type: Optional[str] = Field(None, alias="InputType")
+    maximum_voltage: Optional[int] = Field(None, alias="MaximumVoltage")
+    minimum_voltage: Optional[int] = Field(None, alias="MinimumVoltage")
+    output_wattage: Optional[int] = Field(None, alias="OutputWattage")
+
+
+class PowerSupply(Entity):
+    """
+    Represents a power supply unit (PSU).
+    Embedded in Power resource.
+
+    """
+    firmware_version: Optional[str] = Field(None, alias="FirmwareVersion")
+    input_ranges: Optional[List[InputRange]] = Field(None, alias="InputRanges")
+    power_output_watts: Optional[int] = Field(None, alias="PowerOutputWatts", validate="type=int")
+    # LineInputVoltage is defined as Number in DMTF Redfish PowerSupply schema,
+    # which allows fractional values (e.g. 220.5). Use float to match the spec.
+    line_input_voltage: Optional[float] = Field(None, alias="LineInputVoltage")
+    line_input_voltage_type: Optional[str] = Field(None, alias="LineInputVoltageType")
+    manufacturer: Optional[str] = Field(None, alias="Manufacturer", validate="type=str")
+    member_id: Optional[str] = Field(None, alias="MemberId")
+    model: Optional[str] = Field(None, alias="Model", validate="type=str")
+    part_number: Optional[str] = Field(None, alias="PartNumber")
+    power_capacity_watts: Optional[int] = Field(None, alias="PowerCapacityWatts", validate="type=int,gt=0")
+    last_power_output_watts: Optional[int] = Field(None, alias="LastPowerOutputWatts")
+    power_supply_type: Optional[str] = Field(None, alias="PowerSupplyType")
+    related_item: Optional[List[Link]] = Field(None, alias="RelatedItem")
+    serial_number: Optional[str] = Field(None, alias="SerialNumber", validate="type=str")
+    spare_part_number: Optional[str] = Field(None, alias="SparePartNumber")
+    power_input_watts: Optional[int] = Field(None, alias="PowerInputWatts", validate="type=int")
+    redundancy: Optional[List[Redundancy]] = Field(None, alias="Redundancy")
+    status: Optional[Status] = Field(None, alias="Status", validate="status")
+    oem: Optional[Oem] = Field(None, alias="Oem")
+
+
+class Voltage(BaseModel):
+    """Voltage sensor reading."""
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    member_id: Optional[str] = Field(None, alias="MemberId")
+    name: Optional[str] = Field(None, alias="Name")
+    physical_context: Optional[str] = Field(None, alias="PhysicalContext")
+    reading_volts: Optional[float] = Field(None, alias="ReadingVolts")
+    status: Optional[Status] = Field(None, alias="Status")
+    upper_threshold_critical: Optional[float] = Field(None, alias="UpperThresholdCritical")
+    lower_threshold_critical: Optional[float] = Field(None, alias="LowerThresholdCritical")
+
+
+class PowerControl(BaseModel):
+    """Represents overall power consumption metrics."""
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    member_id: Optional[str] = Field(None, alias="MemberId")
+    name: Optional[str] = Field(None, alias="Name")
+    power_capacity_watts: Optional[int] = Field(None, alias="PowerCapacityWatts")
+    power_consumed_watts: Optional[float] = Field(None, alias="PowerConsumedWatts")
+    power_requested_watts: Optional[float] = Field(None, alias="PowerRequestedWatts")
+    power_available_watts: Optional[float] = Field(None, alias="PowerAvailableWatts")
+    power_allocated_watts: Optional[float] = Field(None, alias="PowerAllocatedWatts")
+
+
+class Power(Entity):
+    """
+    Power data (PSUs, voltages, power controls) for a chassis.
+    Endpoint: /redfish/v1/Chassis/{chassisId}/Power
+
+    """
+    power_control: Optional[List[PowerControl]] = Field(None, alias="PowerControl")
+    power_supplies: Optional[List[PowerSupply]] = Field(None, alias="PowerSupplies")
+    redundancy: Optional[List[Redundancy]] = Field(None, alias="Redundancy")
+    voltages: Optional[List[Voltage]] = Field(None, alias="Voltages")
+    oem: Optional[Oem] = Field(None, alias="Oem")