pydxdiag.schema package

pydxdiag.schema package#

Subpackages#

Submodules#

pydxdiag.schema.DirectXDebugLevels module#

class pydxdiag.schema.DirectXDebugLevels.D3DDebugInformation(*, Current: int, Max: int, Runtime: str | None = None)#

Bases: GeneralDXDebugLevelInformation

Debug information of the D3D

Params Current:: The current debug level of the D3D
Types Current:: int
Params Max:: The maximum debug level of the D3D
Types Max:: int
Params Runtime:: The runtime for the D3D
Types Runtime:: Optional[str]

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}#: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {}#: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'Current': FieldInfo(annotation=int, required=True, title='Current Debug Level', description='The current debug level of the DirectX Component'), 'Max': FieldInfo(annotation=int, required=True, title='Maximum Debug Level', description='The maximum debug level of the DirectX Component'), 'Runtime': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, title='Runtime', description='The runtime for the DirectX Component')}#

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class pydxdiag.schema.DirectXDebugLevels.DirectDrawDebugInformation(*, Current: int, Max: int, Runtime: str | None = None)#

Bases: GeneralDXDebugLevelInformation

Debug information of the DirectDraw

Params Current:: The current debug level of the DirectDraw
Types Current:: int
Params Max:: The maximum debug level of the DirectDraw
Types Max:: int
Params Runtime:: The runtime for the DirectDraw
Types Runtime:: Optional[str]

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}#: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {}#: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class pydxdiag.schema.DirectXDebugLevels.DirectInputDebugInformation(*, Current: int, Max: int, Runtime: str | None = None)#

Bases: GeneralDXDebugLevelInformation

Debug information of the DirectInput

Params Current:: The current debug level of the DirectInput
Types Current:: int
Params Max:: The maximum debug level of the DirectInput
Types Max:: int
Params Runtime:: The runtime for the DirectInput
Types Runtime:: Optional[str]

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}#: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {}#: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class pydxdiag.schema.DirectXDebugLevels.DirectMusicDebugInformation(*, Current: int, Max: int, Runtime: str | None = None)#

Bases: GeneralDXDebugLevelInformation

Debug information of the DirectMusic

Params Current:: The current debug level of the DirectMusic
Types Current:: int
Params Max:: The maximum debug level of the DirectMusic
Types Max:: int
Params Runtime:: The runtime for the DirectMusic
Types Runtime:: Optional[str]

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}#: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {}#: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class pydxdiag.schema.DirectXDebugLevels.DirectPlayDebugInformation(*, Current: int, Max: int, Runtime: str | None = None)#

Bases: GeneralDXDebugLevelInformation

Debug information of the DirectPlay

Params Current:: The current debug level of the DirectPlay
Types Current:: int
Params Max:: The maximum debug level of the DirectPlay
Types Max:: int
Params Runtime:: The runtime for the DirectPlay
Types Runtime:: Optional[str]

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}#: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {}#: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class pydxdiag.schema.DirectXDebugLevels.DirectShowDebugInformation(*, Current: int, Max: int, Runtime: str | None = None)#

Bases: GeneralDXDebugLevelInformation

Debug information of the DirectShow

Params Current:: The current debug level of the DirectShow
Types Current:: int
Params Max:: The maximum debug level of the DirectShow
Types Max:: int
Params Runtime:: The runtime for the DirectShow
Types Runtime:: Optional[str]

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}#: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {}#: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class pydxdiag.schema.DirectXDebugLevels.DirectSoundDebugInformation(*, Current: int, Max: int, Runtime: str | None = None)#

Bases: GeneralDXDebugLevelInformation

Debug information of the DirectSound

Params Current:: The current debug level of the DirectSound
Types Current:: int
Params Max:: The maximum debug level of the DirectSound
Types Max:: int
Params Runtime:: The runtime for the DirectSound
Types Runtime:: Optional[str]

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}#: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {}#: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class pydxdiag.schema.DirectXDebugLevels.DirectXDebugLevels#

Bases: object

Debug levels of the DirectX

Params D3DDebugInformation:: The debug information of the D3D
Types D3DDebugInformation:: D3DDebugInformation
Params DirectDrawDebugInformation:: The debug information of the DirectDraw
Types DirectDrawDebugInformation:: DirectDrawDebugInformation
Params DirectInputDebugInformation:: The debug information of the DirectInput
Types DirectInputDebugInformation:: DirectInputDebugInformation
Params DirectMusicDebugInformation:: The debug information of the DirectMusic
Types DirectMusicDebugInformation:: DirectMusicDebugInformation
Params DirectPlayDebugInformation:: The debug information of the DirectPlay
Types DirectPlayDebugInformation:: DirectPlayDebugInformation
Params DirectSoundDebugInformation:: The debug information of the DirectSound
Types DirectSoundDebugInformation:: DirectSoundDebugInformation
Params DirectShowDebugInformation:: The debug information of the DirectShow
Types DirectShowDebugInformation:: DirectShowDebugInformation

model_dump() → Dict[str, Any]#

Function to dump the model in a dictionary.

Returns:: The dumped model
Return type:: Dict[str, Any]

class pydxdiag.schema.DirectXDebugLevels.GeneralDXDebugLevelInformation(*, Current: int, Max: int, Runtime: str | None = None)#

Bases: BaseModel

A class for storing the general debug information of the DirectX Component

Params Current:: The current debug level of the DirectX Component.
Types Current:: int
Params Max:: The maximum debug level of the DirectX Component.
Types Max:: int
Params Runtime:: The runtime for the DirectX Component.
Types Runtime:: Optional[str]

Current: int#

Max: int#

Runtime: str | None#

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}#: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {}#: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

pydxdiag.schema.DxDiagNotes module#

class pydxdiag.schema.DxDiagNotes.DisplayTabNotes(*, Notes: str, Type: str = 'DisplayTab')#

Bases: GeneralDXDiagNotes

Class to represent display tab notes.

Inherits from GeneralDXDiagNotes.

Type: str#

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}#: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {}#: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'Notes': FieldInfo(annotation=str, required=True), 'Type': FieldInfo(annotation=str, required=False, default='DisplayTab')}#

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class pydxdiag.schema.DxDiagNotes.GeneralDXDiagNotes(*, Notes: str, Type: str)#

Bases: BaseModel

Class to represent general dxdiag notes.

Params Notes:: Notes
Params Type:: Type of the notes

Notes: str#

Type: str#

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}#: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {}#: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'Notes': FieldInfo(annotation=str, required=True), 'Type': FieldInfo(annotation=str, required=True)}#

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class pydxdiag.schema.DxDiagNotes.InputTabNotes(*, Notes: str, Type: str = 'InputTab')#

Bases: GeneralDXDiagNotes

Class to represent input tab notes.

Inherits from GeneralDXDiagNotes.

Type: str#

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}#: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {}#: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'Notes': FieldInfo(annotation=str, required=True), 'Type': FieldInfo(annotation=str, required=False, default='InputTab')}#

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class pydxdiag.schema.DxDiagNotes.SoundTabNotes(*, Notes: str, Type: str = 'SoundTab')#

Bases: GeneralDXDiagNotes

Class to represent sound tab notes.

Inherits from GeneralDXDiagNotes.

Type: str#

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}#: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {}#: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'Notes': FieldInfo(annotation=str, required=True), 'Type': FieldInfo(annotation=str, required=False, default='SoundTab')}#

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

pydxdiag.schema.EnvPowerInformation module#

class pydxdiag.schema.EnvPowerInformation.BalanceFlags(*, Flags: int, EnabledOptions: List[str], DecodePowerUsage: int)#

Bases: GeneralEnvPowerFlags

Class to represent balance flags of the general environment power flags.

Inherits from GeneralEnvPowerFlags.

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}#: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {}#: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'DecodePowerUsage': FieldInfo(annotation=int, required=True), 'EnabledOptions': FieldInfo(annotation=List[str], required=True), 'Flags': FieldInfo(annotation=int, required=True)}#

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class pydxdiag.schema.EnvPowerInformation.EnvPowerInformation(*, GUID: str, Mode: str, QualityFlagsInfo: QualityFlags, BalanceFlagsInfo: BalanceFlags, PowerFlagsInfo: PowerFlags)#

Bases: BaseModel

Class to describe environment power information.

Params GUID:: GUID of the environment power information
Params Mode:: Mode of the environment power information
Params QualityFlagsInfo:: Quality flags information of the environment power information
Params BalanceFlagsInfo:: Balance flags information of the environment power information
Params PowerFlagsInfo:: Power flags information of the environment power information

BalanceFlagsInfo: BalanceFlags#

GUID: str#

Mode: str#

PowerFlagsInfo: PowerFlags#

QualityFlagsInfo: QualityFlags#

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}#: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {}#: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'BalanceFlagsInfo': FieldInfo(annotation=BalanceFlags, required=True), 'GUID': FieldInfo(annotation=str, required=True), 'Mode': FieldInfo(annotation=str, required=True), 'PowerFlagsInfo': FieldInfo(annotation=PowerFlags, required=True), 'QualityFlagsInfo': FieldInfo(annotation=QualityFlags, required=True)}#

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class pydxdiag.schema.EnvPowerInformation.GeneralEnvPowerFlags(*, Flags: int, EnabledOptions: List[str], DecodePowerUsage: int)#

Bases: BaseModel

Abstract class to represent general environment power flags.

Params Flags:: Flags of the general environment power flags
Params EnabledOptions:: Enabled options of the general environment power flags
Params DecodePowerUsage:: Decode power usage of the general environment power flags

DecodePowerUsage: int#

EnabledOptions: List[str]#

Flags: int#

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}#: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {}#: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class pydxdiag.schema.EnvPowerInformation.PowerFlags(*, Flags: int, EnabledOptions: List[str], DecodePowerUsage: int)#

Bases: GeneralEnvPowerFlags

Class to represent power flags of the general environment power flags.

Inherits from GeneralEnvPowerFlags.

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}#: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {}#: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class pydxdiag.schema.EnvPowerInformation.QualityFlags(*, Flags: int, EnabledOptions: List[str], DecodePowerUsage: int)#

Bases: GeneralEnvPowerFlags

Class to represent quality flags of the general environment power flags.

Inherits from GeneralEnvPowerFlags.

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}#: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {}#: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

pydxdiag.schema.Filter module#

class pydxdiag.schema.Filter.Filter(*, Name: str, FilterCategory: str, Merit: int, Inputs: int, Outputs: int, File: str, FileVersion: str)#

Bases: BaseModel

Class to represent a filter for DirectShow section of dxdiag output.

Params Name:: Name of the filter
Params FilterCategory:: Filter category
Params Merit:: Merit value of the filter
Params Inputs:: Filter inputs
Params Outputs:: Filter outputs
Params File:: File name of the filter
Params FileVersion:: File version of the filter

File: str#

FileVersion: str#

FilterCategory: str#

Inputs: int#

Merit: int#

Name: str#

Outputs: int#

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}#: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {}#: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'File': FieldInfo(annotation=str, required=True), 'FileVersion': FieldInfo(annotation=str, required=True), 'FilterCategory': FieldInfo(annotation=str, required=True), 'Inputs': FieldInfo(annotation=int, required=True), 'Merit': FieldInfo(annotation=int, required=True), 'Name': FieldInfo(annotation=str, required=True), 'Outputs': FieldInfo(annotation=int, required=True)}#

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class pydxdiag.schema.Filter.PreferredDShowFilters(*, MediaSubType: str | None = None, Name: str | None = None, CLSIDType: str | None = None)#

Bases: BaseModel

A class to store the preferred direct show filters

Params MediaSubType:: The media subtype of the filter
Params Name:: The name of the filter
Params CLSIDType:: The CLSID type of the filter

CLSIDType: str | None#

MediaSubType: str | None#

Name: str | None#

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}#: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {}#: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'CLSIDType': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, title='CLSID Type', description='The CLSID type of the filter'), 'MediaSubType': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, title='Media Sub Type', description='The media subtype of the filter'), 'Name': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, title='Name', description='The name of the filter')}#

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

pydxdiag.schema.LogicalDisk module#

class pydxdiag.schema.LogicalDisk.LogicalDisk(*, DriveLetter: str, FreeSpace: int, MaxSpace: int, FileSystem: str, Model: str, PNPDeviceID: str, HardDriveIndex: int)#

Bases: BaseModel

Class to describe basic information for a logical disk.

Params DriveLetter:: The drive letter of the logical disk.
Params FreeSpace:: The free space of the logical disk in bytes.
Params MaxSpace:: The max space of the logical disk in bytes.
Params FileSystem:: The file system of the logical disk.
Params Model:: The model of the logical disk.
Params PNPDeviceID:: The PNP device ID of the logical disk.
Params HardDriveIndex:: The driver index of the logical disk.

DriveLetter: str#

FileSystem: str#

FreeSpace: int#

HardDriveIndex: int#

MaxSpace: int#

Model: str#

PNPDeviceID: str#

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}#: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {}#: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'DriveLetter': FieldInfo(annotation=str, required=True, title='DriveLetter', description='The drive letter of the logical disk.'), 'FileSystem': FieldInfo(annotation=str, required=True, title='FileSystem', description='The file system of the logical disk.'), 'FreeSpace': FieldInfo(annotation=int, required=True, title='FreeSpace', description='The free space of the logical disk in bytes.'), 'HardDriveIndex': FieldInfo(annotation=int, required=True, title='HardDriveIndex', description='The driver index of the logical disk.'), 'MaxSpace': FieldInfo(annotation=int, required=True, title='MaxSpace', description='The max space of the logical disk in bytes.'), 'Model': FieldInfo(annotation=str, required=True, title='Model', description='The model of the logical disk.'), 'PNPDeviceID': FieldInfo(annotation=str, required=True, title='PNPDeviceID', description='The PNP device ID of the logical disk.')}#

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

pydxdiag.schema.SystemInformation module#

class pydxdiag.schema.SystemInformation.CPUInformation(*, Gen: int | None, BaseClock: float, Threads: int, Brand: str, Name: str)#

Bases: BaseModel

A class for storing the CPU information from device.

Params Gen:: The generation of the CPU
Types Gen:: Optional[int]
Params BaseClock:: The base clock frequency of the current CPU
Types BaseClock:: float
Params Threads:: The number of threads of the current CPU
Types Threads:: int
Params Brand:: The brand of the CPU
Types Brand:: str
Params Name:: The name of the CPU
Types Name:: str

BaseClock: float#

Brand: str#

Gen: int | None#

Name: str#

Threads: int#

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}#: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {}#: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'BaseClock': FieldInfo(annotation=float, required=True, title='Base Clock', description='The base clock frquency of the current CPU'), 'Brand': FieldInfo(annotation=str, required=True, title='CPU Brand', description='The brand of the CPU'), 'Gen': FieldInfo(annotation=Union[int, NoneType], required=True, title='CPU Generation', description='The generation of the CPU'), 'Name': FieldInfo(annotation=str, required=True, title='CPU Name', description='The name of the CPU'), 'Threads': FieldInfo(annotation=int, required=True, title='Threads', description='The number of threads of the current CPU')}#

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class pydxdiag.schema.SystemInformation.DXDiagInformation(*, Version: str, UnicodeEnabled: bool, Is64Bit: bool, MiracastAvailable: bool, MSHybrid: bool, DatabaseVersion: str)#

Bases: BaseModel

A class for storing Dxdiag information from device

Params Version:: The version of the Dxdiag.exe
Types Version:: str
Params UnicodeEnabled:: Whether if the Unicode is enabled on dxdiag
Types UnicodeEnabled:: bool
Params Is64Bit:: Whether if the dxdiag is 64 bit
Types Is64Bit:: bool
Params MiracastAvailable:: Whether if the Miracast is available
Types MiracastAvailable:: bool
Params MSHybrid:: Whether if the MS Hybrid is available
Types MSHybrid:: bool
Params DatabaseVersion:: The version of the database
Types DatabaseVersion:: str

DatabaseVersion: str#

Is64Bit: bool#

MSHybrid: bool#

MiracastAvailable: bool#

UnicodeEnabled: bool#

Version: str#

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}#: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {}#: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'DatabaseVersion': FieldInfo(annotation=str, required=True, title='Database Version', description='The version of the database'), 'Is64Bit': FieldInfo(annotation=bool, required=True, title='64 Bit', description='Whether if the dxdiag is 64 bit'), 'MSHybrid': FieldInfo(annotation=bool, required=True, title='MS Hybrid', description='Whether if the MS Hybrid is available'), 'MiracastAvailable': FieldInfo(annotation=bool, required=True, title='Miracast Available', description='Whether if the Miracast is available'), 'UnicodeEnabled': FieldInfo(annotation=bool, required=True, title='Unicode Enabled', description='Whether if the Unicode is enabled on dxdiag'), 'Version': FieldInfo(annotation=str, required=True, title='Dxdiag Version', description='The version of the Dxdiag.exe')}#

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class pydxdiag.schema.SystemInformation.FirmwareInformation(*, FirmwareType: str, BIOSVersion: str)#

Bases: BaseModel

A class for storaging the firmware information

Params FirmwareType:: The type of the firmware
Types FirmwareType:: str
Params BIOSVersion:: The BIOS version
Types BIOSVersion:: str

BIOSVersion: str#

FirmwareType: str#

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}#: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {}#: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'BIOSVersion': FieldInfo(annotation=str, required=True, title='BIOS Version', description='The BIOS version'), 'FirmwareType': FieldInfo(annotation=str, required=True, title='Firmware Type', description='The type of the firmware')}#

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class pydxdiag.schema.SystemInformation.GraphicsInformation(*, Version: int, SetupParamaters: str | None = None, UserDPI: int, UserDPIScale: int, SystemDPI: int, DWMDPIScaling: Any)#

Bases: BaseModel

A class for storing the DirectX graphics information from device.

Parmas Version:: The version of the DirectX
Types Version:: int
Params SetupParamaters:: The setup parameters of the DirectX
Types SetupParamaters:: Optional[str]
Params UserDPI:: The DPI of the user
Types UserDPI:: int
Params UserDPIScale:: The DPI scale of the user
Types UserDPIScale:: int
Params SystemDPI:: The DPI of the system
Types SystemDPI:: int
Params DWMDPIScaling:: The DPI scaling of the DWM
Types DWMDPIScaling:: Any

DWMDPIScaling: Any#

SetupParamaters: str | None#

SystemDPI: int#

UserDPI: int#

UserDPIScale: int#

Version: int#

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}#: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {}#: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'DWMDPIScaling': FieldInfo(annotation=Any, required=True, title='DWM DPI Scaling', description='The DPI scaling of the DWM'), 'SetupParamaters': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, title='Setup Parameters', description='The setup parameters of the DirectX'), 'SystemDPI': FieldInfo(annotation=int, required=True, title='System DPI', description='The DPI of the system'), 'UserDPI': FieldInfo(annotation=int, required=True, title='User DPI', description='The DPI of the user'), 'UserDPIScale': FieldInfo(annotation=int, required=True, title='User DPI Scale', description='The DPI scale of the user'), 'Version': FieldInfo(annotation=int, required=True, title='DirectX Version', description='The version of the DirectX')}#

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class pydxdiag.schema.SystemInformation.MachineInformation(*, MachineName: str, MachineId: str)#

Bases: BaseModel

A class for storing the basic information of the device.

Params MachineName:: The name of the machine
Types MachineName:: str
Params MachineId:: The ID of the machine
Types MachineId:: str

MachineId: str#

MachineName: str#

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}#: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {}#: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'MachineId': FieldInfo(annotation=str, required=True, title='Machine ID', description='The ID of the machine'), 'MachineName': FieldInfo(annotation=str, required=True, title='Machine Name', description='The name of the machine')}#

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class pydxdiag.schema.SystemInformation.MemoryInformation(*, MemorySize: int, AvailableMemory: int, InusedPageFile: int, AvailablePageFile: int)#

Bases: BaseModel

A class for storing the memory information from device.

Params MemorySize:: The size of the memory in bytes
Types MemorySize:: int
Params AvailableMemory:: The available memory in bytes
Types AvailableMemory:: int
Params InusedPageFile:: The inused page file in bytes
Types InusedPageFile:: int
Params AvailablePageFile:: The available page file in bytes

AvailableMemory: int#

AvailablePageFile: int#

InusedPageFile: int#

MemorySize: int#

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}#: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {}#: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'AvailableMemory': FieldInfo(annotation=int, required=True, title='Available Memory in bytes', description='The available memory in bytes'), 'AvailablePageFile': FieldInfo(annotation=int, required=True, title='Available Page File in bytes', description='The available page file in bytes'), 'InusedPageFile': FieldInfo(annotation=int, required=True, title='Inused Page File in bytes', description='The inused page file in bytes'), 'MemorySize': FieldInfo(annotation=int, required=True, title='Memory Size in bytes', description='The size of the memory in bytes')}#

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class pydxdiag.schema.SystemInformation.OSInformation(*, Name: str, Version: int, Bit: int, BuildId: int, ReleaseId: str, Language: str)#

Bases: BaseModel

A class for storing the OS information of the device.

Params Name:: The name of the OS
Types Name:: str
Params Version:: The version of the OS
Types Version:: int
Params Bit:: The bit of the OS
Types Bit:: int
Params BuildId:: The build ID of the OS
Types BuildId:: int
Params ReleaseId:: The release ID of the OS
Types ReleaseId:: str
Params Language:: The language of the OS
Types Language:: str

Bit: int#

BuildId: int#

Language: str#

Name: str#

ReleaseId: str#

Version: int#

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}#: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {}#: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'Bit': FieldInfo(annotation=int, required=True, title='OS Bit', description='The bit of the OS'), 'BuildId': FieldInfo(annotation=int, required=True, title='OS Build ID', description='The build ID of the OS'), 'Language': FieldInfo(annotation=str, required=True, title='OS Language', description='The language of the OS'), 'Name': FieldInfo(annotation=str, required=True, title='OS Name', description='The name of the OS'), 'ReleaseId': FieldInfo(annotation=str, required=True, title='OS Release ID', description='The release ID of the OS'), 'Version': FieldInfo(annotation=int, required=True, title='OS Version', description='The version of the OS')}#

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class pydxdiag.schema.SystemInformation.SystemModelInformation(*, SystemManufacturer: str, SystemModel: str)#

Bases: BaseModel

A class storage for the system model information

whether if your machine is an OEM model or not.

Params SystemManufacturer:: The manufacturer of the system
Types SystemManufacturer:: str
Params SystemModel:: The model of the system
Types SystemModel:: str

SystemManufacturer: str#

SystemModel: str#

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}#: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {}#: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'SystemManufacturer': FieldInfo(annotation=str, required=True, title='System Manufacturer', description='The manufacturer name of the system'), 'SystemModel': FieldInfo(annotation=str, required=True, title='System Model', description='The model name of the system')}#

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

pydxdiag.schema.WER module#

class pydxdiag.schema.WER.ProblemSignature#

Bases: object

Basic class to describe a problem signature entry.

Params P1:
Params P2:
Params P3:
Params P4:
Params P5:
Params P6:
Params P7:
Params P8:
Params P9:
Params P10:

P1: str | None = FieldInfo(annotation=NoneType, required=False, default=None, title='P1')#

P10: str | None = FieldInfo(annotation=NoneType, required=False, default=None, title='P10')#

P2: str | None = FieldInfo(annotation=NoneType, required=False, default=None, title='P2')#

P3: str | None = FieldInfo(annotation=NoneType, required=False, default=None, title='P3')#

P4: str | None = FieldInfo(annotation=NoneType, required=False, default=None, title='P4')#

P5: str | None = FieldInfo(annotation=NoneType, required=False, default=None, title='P5')#

P6: str | None = FieldInfo(annotation=NoneType, required=False, default=None, title='P6')#

P7: str | None = FieldInfo(annotation=NoneType, required=False, default=None, title='P7')#

P8: str | None = FieldInfo(annotation=NoneType, required=False, default=None, title='P8')#

P9: str | None = FieldInfo(annotation=NoneType, required=False, default=None, title='P9')#

model_dump() → Dict[str, str]#

Function to dump the model into a dictionary.

Returns:: A dictionary containing the model
Return type:: Dict[str, str]

class pydxdiag.schema.WER.WERInformation(FaultBucket: str, EventName: str, Response: str, CabId: int, ProblemSignatures: ProblemSignature)#

Bases: object

Basic class to describe a Windows Error Reporting (WER) entry.

Params FaultBucket:: The bucket ID for the error
Params EventName:: The name of the event
Params Response:: The response of the event
Params CabId:: The CAB ID for the event
Params ProblemSignatures:: The problem signature for the event

model_dump() → Dict[str, Any]#

Function to dump the model into a dictionary.

Returns:: A dictionary containing the model
Return type:: Dict[str, Any]

pydxdiag.schema package

Contents

pydxdiag.schema package#

Subpackages#

Submodules#

pydxdiag.schema.DirectXDebugLevels module#

pydxdiag.schema.DxDiagNotes module#

pydxdiag.schema.EnvPowerInformation module#

pydxdiag.schema.Filter module#

pydxdiag.schema.LogicalDisk module#

pydxdiag.schema.SystemInformation module#

pydxdiag.schema.WER module#

Module contents#