### Install vsphere-automation-sdk for ESXi Hosts

Source: https://github.com/intel/mfd-host/blob/main/README.md

Provides the bash command to install the `vsphere-automation-sdk`, a prerequisite for managing ESXi hosts within the MFD Host project. It specifies installing from a Git repository for a specific version.

```bash
pip install vsphere-automation-sdk @ git+https://github.com/vmware/vsphere-automation-sdk-python@v8.0.3.0
```

--------------------------------

### Virtualization Hypervisor Method Examples (Python)

Source: https://github.com/intel/mfd-host/blob/main/README.md

Provides example usage of virtualization methods specific to different hypervisors (HyperV, ESXi, KVM) through a host object's virtualization attribute. These methods allow for VM creation, network switch addition, and VM attachment.

```python
# HyperV
host.virtualization.create_vm(...)

# ESXI
host.virtualization.add_vswitch(...)

# KVM
host.virtualization.attach_vm(...)
```

--------------------------------

### Start irqbalance Service (Linux)

Source: https://github.com/intel/mfd-host/blob/main/README.md

Starts the irqbalance service on a Linux system. This service helps in distributing hardware interrupts across available CPUs.

```python
start_irqbalance():
```

--------------------------------

### Interact with Network Features via Host Object in Python

Source: https://github.com/intel/mfd-host/blob/main/README.md

Illustrates how to access and utilize network management functionalities provided by the MFD Host. Examples include getting interfaces, deleting VXLAN configurations, and removing all VLANs.

```python
host.network.get_interfaces(all_interfaces=True)
host.network.vxlan.delete_vxlan(vxlan_name="vxlan")
host.network.vlan.remove_all_vlans()
```

--------------------------------

### Get Error Description (Windows)

Source: https://github.com/intel/mfd-host/blob/main/README.md

Fetches a human-readable description for a given device error code on Windows systems. This aids in diagnosing device-related issues.

```python
get_description_for_code(error_code: int):
```

--------------------------------

### Get Physical CPU Count (Windows)

Source: https://github.com/intel/mfd-host/blob/main/README.md

Retrieves the number of physical CPUs installed in a Windows system. This method is crucial for hardware inventory and system configuration analysis.

```python
get_phy_cpu_no(self) -> int
```

--------------------------------

### Get Device Resources (Windows)

Source: https://github.com/intel/mfd-host/blob/main/README.md

Retrieves the resources allocated to specified devices on a Windows system, with an option to filter resources. This helps in understanding device configuration and potential conflicts.

```python
get_resources(device_id: str, pattern: str, resource_filter: str):
```

--------------------------------

### Get Core Count (ESXi)

Source: https://github.com/intel/mfd-host/blob/main/README.md

Fetches the number of CPU cores available in an ESXi system. This is a fundamental metric for understanding the system's processing capacity.

```python
cores(self) -> int
```

--------------------------------

### Get CPU Statistics (Linux)

Source: https://github.com/intel/mfd-host/blob/main/README.md

Retrieves detailed CPU statistics for a Linux system, returned as a dictionary. This includes metrics like user time, system time, idle time, and more, useful for performance monitoring.

```python
get_cpu_stats(self) -> Dict[str, Dict[str, str]]
```

--------------------------------

### Get NUMA Node Count (ESXi)

Source: https://github.com/intel/mfd-host/blob/main/README.md

Fetches the number of NUMA nodes in an ESXi environment. This function is part of the system's hardware resource introspection capabilities.

```python
packages(self) -> int
```

--------------------------------

### Get Thread Count (ESXi)

Source: https://github.com/intel/mfd-host/blob/main/README.md

Fetches the number of CPU threads available in an ESXi system. This count typically reflects the total logical processors, considering hyperthreading.

```python
threads(self) -> int
```

--------------------------------

### Get Logical CPU Count (Windows)

Source: https://github.com/intel/mfd-host/blob/main/README.md

Retrieves the number of logical CPUs available in a Windows system. This includes cores and hyperthreaded processors, providing a measure of the system's processing power.

```python
get_log_cpu_no(self) -> int
```

--------------------------------

### Get Device Status (Windows)

Source: https://github.com/intel/mfd-host/blob/main/README.md

Retrieves the current status of a device using its index on a Windows system. This function is useful for monitoring device health and operational state.

```python
get_device_status(device_index: int):
```

--------------------------------

### Disable Devices (Windows)

Source: https://github.com/intel/mfd-host/blob/main/README.md

Disables specified devices on a Windows computer. This function is useful for temporarily deactivating devices, for example, during troubleshooting. A reboot option is available.

```python
disable_devices(device_id: str, pattern: str, reboot: bool):
```

--------------------------------

### Get CPU Core Information (Windows)

Source: https://github.com/intel/mfd-host/blob/main/README.md

Retrieves detailed CPU information for Windows systems, including device ID, number of physical cores, and logical processors. This function is essential for understanding system's CPU configuration and hyperthreading status.

```python
get_core_info(self) -> List[Dict[str, str]]
```

--------------------------------

### Get NUMA Node Count (Windows)

Source: https://github.com/intel/mfd-host/blob/main/README.md

Retrieves the number of Non-Uniform Memory Access (NUMA) nodes present in a Windows system. This information is vital for understanding memory architecture and optimizing performance in multi-socket systems.

```python
get_numa_node_count(self) -> int
```

--------------------------------

### Instantiate Host Object in Python

Source: https://github.com/intel/mfd-host/blob/main/README.md

Demonstrates how to instantiate the `Host` object in Python, which serves as the primary interface for interacting with a System Under Test (SUT). This process involves setting up connections, power management, and CLI client configurations.

```python
from mfd_connect.util.connection_utils import Connections
from pytest_mfd_config.fixtures import create_host_connections_from_model, create_power_mng_from_model

_connections = create_host_connections_from_model(host_model)
connections = Connections(_connections)

power_mng = create_power_mng_from_model(host_model.power_mng) if host_model.power_mng else None
host = Host(
    connection=_connections[0],
    name=host_model.name,
    cli_client=cli_client,
    connections=connections,
    power_mng=power_mng,
    topology=host_model,
)
```

--------------------------------

### Memory Management Operations (Python)

Source: https://github.com/intel/mfd-host/blob/main/README.md

Illustrates common memory management tasks for Linux systems, including creating and deleting RAM disks, setting huge pages, and retrieving memory channel information. It also shows how to access total RAM on an ESXi host.

```python
from mfd_host.base import Host
from mfd_host import Host
from mfd_connect import RPyCConnection
host = Host(connection=RPyCConnection)

path = "/tmp/ramdisk"
size = 1024 * 1024 # 1 gigabyte
hp_numa = (2048, 2)
host.memory.create_ram_disk(mount_disk=path, ram_disk_size=size)
host.memory.delete_ram_disk(path=path)
host.memory.set_huge_pages(page_size_in_memory=2048, page_size_per_numa_node=hp_numa)
host.memory.get_memory_channels()

esxi_host = Host(connection=RPyCConnection)
esxi_host.memory.ram
```

--------------------------------

### Run Documentation Generation Script (Shell)

Source: https://github.com/intel/mfd-host/blob/main/sphinx-doc/README.md

This command executes the Python script responsible for generating the Sphinx documentation. Ensure you are in an activated virtual environment within the MFD-Host project's sphinx-doc directory.

```shell
$ python generate_docs.py

```

--------------------------------

### Manage Drivers via Host Object in Python

Source: https://github.com/intel/mfd-host/blob/main/README.md

Demonstrates how to use the `driver` attribute of the `Host` object to manage system drivers, such as uninstalling specific modules.

```python
host.driver.uninstall_module(module_name="module_name")
```

--------------------------------

### Utility Functions

Source: https://github.com/intel/mfd-host/blob/main/README.md

Provides utility functions for retrieving network interface information, hostnames, and OS-specific configurations. These functions are available across all supported operating systems, with some specific to Linux or FreeBSD.

```APIDOC
## Utility Functions

This section details utility functions available for system information and configuration.

### All OSes

- **get_interface_by_ip**(ip: IPv4Address | IPv6Address, check_all_interfaces: bool = False) -> "ESXiNetworkInterface | FreeBSDNetworkInterface | LinuxNetworkInterface | WindowsNetworkInterface"
  - Description: Get network interface by matching IP address.
  - Parameters:
    - **ip** (IPv4Address | IPv6Address) - Required - The IP address to search for.
    - **check_all_interfaces** (bool) - Optional - If True, checks all interfaces; otherwise, checks active ones.

- **get_hostname**() -> str
  - Description: Get the hostname of the system.

### Linux Specific

- **remove_ssh_known_host**(host_ip: Union["IPv4Interface", "IPv6Interface"], ssh_client_config_dir: str)
  - Description: Removes a specific host IP from the SSH known hosts configuration.
  - Parameters:
    - **host_ip** (Union[IPv4Interface, IPv6Interface]) - Required - The IP address of the host to remove.
    - **ssh_client_config_dir** (str) - Required - The path to the SSH client configuration directory.

- **start_kedr**(driver_name: str) -> None
  - Description: Attaches the KEDR module to the specified driver.
  - Parameters:
    - **driver_name** (str) - Required - The name of the driver to attach KEDR to.

- **stop_kedr**() -> None
  - Description: Stops the KEDR process.

- **create_unprivileged_user**(username: str, password: str) -> None
  - Description: Creates an unprivileged user account.
  - Parameters:
    - **username** (str) - Required - The username for the new account.
    - **password** (str) - Required - The password for the new account.

- **delete_unprivileged_user**(username: str) -> None
  - Description: Deletes an unprivileged user account.
  - Parameters:
    - **username** (str) - Required - The username of the account to delete.

- **set_icmp_echo**(*, ignore_all: bool = False, ignore_broadcasts: bool = True) -> None
  - Description: Configures ICMP broadcast settings.
  - Parameters:
    - **ignore_all** (bool) - Optional - If True, ignores all ICMP requests.
    - **ignore_broadcasts** (bool) - Optional - If True, ignores ICMP broadcast messages.

### FreeBSD Specific

- **set_icmp_echo**(*, ignore_broadcasts: bool = True, **kwargs) -> None
  - Description: Set ICMP broadcast settings for FreeBSD.
  - Parameters:
    - **ignore_broadcasts** (bool) - Optional - If True, ignores ICMP broadcast messages.
    - **kwargs** - Additional keyword arguments.

```

--------------------------------

### Virtualization Auto-Selection based on OS (Python)

Source: https://github.com/intel/mfd-host/blob/main/README.md

Demonstrates how to automatically select the appropriate hypervisor class (KVM, HyperV, ESXi) based on the detected operating system. This uses a dictionary mapping OSName enums to their respective hypervisor classes.

```python
os_name_to_class = {
    OSName.LINUX: KVMHypervisor,
    OSName.FREEBSD: KVMHypervisor,
    OSName.WINDOWS: HypervHypervisor,
    OSName.ESXI: ESXiHypervisor,
}
```

--------------------------------

### Virtualization

Source: https://github.com/intel/mfd-host/blob/main/README.md

Interact with virtualization hypervisors like Hyper-V, KVM, and ESXi. The system automatically selects the appropriate hypervisor based on the operating system. You can use the `virtualization` attribute to access specific hypervisor methods.

```APIDOC
## Virtualization Overview

This section describes how to interact with different hypervisor objects (HypervHypervisor, KVMHypervisor, ESXiHypervisor) through the `virtualization` attribute of the Host object. The hypervisor is auto-selected based on the operating system.

### Auto-selection Logic

- **Linux/FreeBSD**: `KVMHypervisor`
- **Windows**: `HypervHypervisor`
- **ESXi**: `ESXiHypervisor`

### Available Hypervisors

- **KVM**: [Available API](https://github.com/intel/mfd-kvm)
- **ESXi**: [Available API](https://github.com/intel/mfd-esxi)
- **HyperV**: [Available API](https://github.com/intel/mfd-hyperv)

### Usage Examples

```python
# Example for HyperV
host.virtualization.create_vm(...)

# Example for ESXi
host.virtualization.add_vswitch(...)

# Example for KVM
host.virtualization.attach_vm(...)
```
```

--------------------------------

### Memory Management

Source: https://github.com/intel/mfd-host/blob/main/README.md

Manage memory-related operations such as creating and deleting RAM disks, setting huge pages, and retrieving memory channel information. Specific functions are available for Linux, ESXi, and other OSes.

```APIDOC
## Memory Management

This section covers functions related to memory management, including RAM disk creation/deletion, huge page configuration, and memory statistics.

### Linux Specific

- **create_ram_disk**(mount_disk: Union[Path, str], ram_disk_size: int)
  - Description: Creates a RAM disk at the specified mount point with the given size.
  - Parameters:
    - **mount_disk** (Union[Path, str]) - Required - The path where the RAM disk will be mounted.
    - **ram_disk_size** (int) - Required - The size of the RAM disk in bytes.

- **delete_ram_disk**(path: str)
  - Description: Deletes a RAM disk located at the specified path.
  - Parameters:
    - **path** (str) - Required - The path to the RAM disk to delete.

- **set_huge_pages**(page_size_in_memory: int, page_size_per_numa_node: Optional[Tuple[int, int]] = None, page_size_in_kernel: int = 2048) -> None
  - Description: Configures huge pages in memory and optionally on NUMA nodes.
  - Parameters:
    - **page_size_in_memory** (int) - Required - The desired huge page size in memory.
    - **page_size_per_numa_node** (Optional[Tuple[int, int]]) - Optional - A tuple specifying page size and NUMA node configuration.
    - **page_size_in_kernel** (int) - Optional - The huge page size in the kernel (defaults to 2048).

- **get_memory_channels**() -> int
  - Description: Retrieves the number of memory channels available on the system.

### ESXi Specific

- **ram**() -> int
  - Description: Returns the total amount of RAM in bytes on the ESXi system.

### Usage Examples

```python
# Example for Linux RAM disk and huge pages
host.memory.create_ram_disk(mount_disk="/tmp/ramdisk", ram_disk_size=1024*1024)
host.memory.delete_ram_disk(path="/tmp/ramdisk")
host.memory.set_huge_pages(page_size_in_memory=2048, page_size_per_numa_node=(2048, 2))
host.memory.get_memory_channels()

# Example for ESXi total RAM
esxi_host = Host(connection=RPyCConnection)
esxi_host.memory.ram
```
```

--------------------------------

### Host Class - Event Feature

Source: https://github.com/intel/mfd-host/blob/main/README.md

The `event` attribute provides access to system event logs. For FreeBSD, Linux, and ESXi hosts, it interfaces with `mfd-dmesg`. For Windows hosts, it interfaces with `mfd-event-log`.

```APIDOC
## Host.event

### Description
Provides a pass-through to system event logging utilities. For FreeBSD, Linux, and ESXi hosts, it interfaces with `mfd-dmesg`. For Windows hosts, it interfaces with `mfd-event-log`. Note that the Event feature for Windows supports only `RPyCConnection`.

### Methods
Methods and features are accessible via the `event` attribute. Refer to the respective `mfd-dmesg` or `mfd-event-log` documentation for specific methods.

### Request Example
```python
# Example for Linux/FreeBSD/ESXi:
host.event.get_kernel_messages()

# Example for Windows (requires RPyCConnection):
host.event.get_application_events()
```

### Response
#### Success Response (200)
Responses vary depending on the specific event method called and the host operating system. Refer to `mfd-dmesg` or `mfd-event-log` documentation.

#### Response Example
```json
// Example for get_kernel_messages:
[
  {
    "timestamp": "2023-10-27T10:00:00Z",
    "message": "Kernel message example."
  }
]
```
```

--------------------------------

### Statistics

Source: https://github.com/intel/mfd-host/blob/main/README.md

Collect and retrieve system performance statistics, including CPU utilization, memory usage, and other metrics. Functions are tailored for Linux, FreeBSD, Windows, and ESXi environments.

```APIDOC
## Statistics

This section provides functions for retrieving various system performance statistics.

### Linux Specific

- **get_meminfo**() -> Dict[str, str]
  - Description: Retrieves detailed memory information for the system.

- **get_cpu_utilization**() -> Dict[str, Dict[str, str]]
  - Description: Gets CPU utilization values for all cores, reported as percentages summing up to 1 for each core.

- **get_slabinfo**() -> Dict[str, str]
  - Description: Captures and returns slabinfo results.

- **get_mem_used**() -> int
  - Description: Returns the total amount of memory used in bytes.

- **get_top_stats**(separate_cpu: Optional[bool] = True, memory_scaling: Optional[str] = "", options: Optional[str] = "", friendly_labels: Optional[bool] = True, filter_proc: Optional[List[str]] = []) -> StatsOutput
  - Description: Retrieves top process statistics with various filtering and formatting options.
  - Parameters:
    - **separate_cpu** (Optional[bool]) - If True, separates CPU statistics.
    - **memory_scaling** (Optional[str]) - Memory scaling option.
    - **options** (Optional[str]) - Additional options for the top command.
    - **friendly_labels** (Optional[bool]) - If True, uses friendly labels for output.
    - **filter_proc** (Optional[List[str]]) - A list of process names to filter.

### FreeBSD Specific

- **get_free_memory**() -> int
  - Description: Gets the amount of free memory in MBytes.

- **get_wired_memory**() -> int
  - Description: Gets the amount of wired (non-pageable) memory in MBytes.

- **get_cpu_utilization**() -> Dict[str, Dict[str, str]]
  - Description: Gets CPU utilization. Utilization is calculated based on the time spent by cores in different states since the last call.

### Windows Specific

- **get_meminfo**() -> Dict[str, int]
  - Description: Retrieves memory information for the system.

- **get_cpu_utilization**() -> float
  - Description: Gets the CPU utilization value.

- **get_dpc_rate**(interval: int, samples: int) -> Dict[str, int]
  - Description: Retrieves DPC Rate values from the performance monitor.
  - Parameters:
    - **interval** (int) - Required - The interval in seconds for collecting samples.
    - **samples** (int) - Required - The number of samples to collect.

### ESXi Specific

- **get_meminfo**() -> Dict[str, int]
  - Description: Retrieves memory information for the system.

```

--------------------------------

### Host Class - Network Feature

Source: https://github.com/intel/mfd-host/blob/main/README.md

The `network` attribute provides access to the `mfd-network-adapter`'s features, allowing management of network interfaces, VLANs, VXLANs, and more.

```APIDOC
## Host.network

### Description
Provides a pass-through to the `mfd-network-adapter`'s owner object, enabling the use of its methods and features via the `network` attribute.

### Available API
[mfd-network-adapter](https://github.com/intel/mfd-network-adapter)

### Methods
Refer to the `mfd-network-adapter` documentation for a full list of available methods. Examples include:

- `host.network.get_interfaces(all_interfaces=True)`
- `host.network.vxlan.delete_vxlan(vxlan_name="vxlan")`
- `host.network.vlan.remove_all_vlans()`

### Request Example
```python
# Get all interfaces
all_interfaces = host.network.get_interfaces(all_interfaces=True)

# Delete a VXLAN interface
host.network.vxlan.delete_vxlan(vxlan_name="vxlan_test")

# Remove all VLAN interfaces
host.network.vlan.remove_all_vlans()
```

### Response
#### Success Response (200)
Responses vary depending on the specific network method called. Refer to `mfd-network-adapter` documentation.

#### Response Example
```json
// Example for get_interfaces:
{
  "interface_name": "eth0",
  "mac_address": "00:11:22:33:44:55",
  "ip_address": "192.168.1.100"
}
```
```

--------------------------------

### Host Class - Driver Feature

Source: https://github.com/intel/mfd-host/blob/main/README.md

The `driver` attribute provides access to the `mfd-package-manager`'s features for managing software modules and drivers on the host.

```APIDOC
## Host.driver

### Description
Provides a pass-through to the `mfd-package-manager`'s object, allowing you to use its methods and features through the `driver` attribute.

### Available API
[mfd-package-manager](https://github.com/intel/mfd-package-manager)

### Methods
Refer to the `mfd-package-manager` documentation for a full list of available methods. An example includes:

- `host.driver.uninstall_module(module_name="module_name")`

### Request Example
```python
# Uninstall a specific module
host.driver.uninstall_module(module_name="my_driver_module")
```

### Response
#### Success Response (200)
Responses vary depending on the specific driver method called. Refer to `mfd-package-manager` documentation.

#### Response Example
```json
{
  "status": "success",
  "message": "Module my_driver_module uninstalled successfully."
}
```
```

--------------------------------

### Set State for Multiple Devices (Windows)

Source: https://github.com/intel/mfd-host/blob/main/README.md

Sets the state (enable/disable) for multiple Windows network interface devices specified through a list. This allows for batch configuration of devices.

```python
set_state_for_multiple_devices(device_list: list["WindowsNetworkInterface"], state: State):
```

--------------------------------

### Restart libvirtd Service (Linux)

Source: https://github.com/intel/mfd-host/blob/main/README.md

Restarts the libvirtd service specifically on a Linux system. This is useful for managing virtualization environments that rely on libvirt.

```python
restart_libvirtd():
```

--------------------------------

### Automate Git Commit Signing with Git Config

Source: https://github.com/intel/mfd-host/blob/main/CONTRIBUTING.md

This snippet demonstrates how to configure your git client to automatically sign your commits. By setting the 'user.name' and 'user.email' git configurations, you can use the '-s' flag with 'git commit' to append the sign-off line automatically.

```git
git commit -s
```

--------------------------------

### Affinitize Queues to CPUs (Linux)

Source: https://github.com/intel/mfd-host/blob/main/README.md

Executes a script to affinitize interrupt request (IRQ) queues to specific CPUs on a Linux system for a given network adapter. This is an advanced performance tuning technique.

```python
affinitize_queues_to_cpus(self, adapter: str, scriptdir: str) -> None
```

--------------------------------

### Verify Device State (Windows)

Source: https://github.com/intel/mfd-host/blob/main/README.md

Checks if a specified Windows network interface device is in the expected state and if its resources are available as anticipated. This is crucial for ensuring network connectivity and proper device operation.

```python
verify_device_state(device: "WindowsNetworkInterface", state: State):
```

--------------------------------

### Refresh Host Network Interfaces in Python

Source: https://github.com/intel/mfd-host/blob/main/README.md

Shows how to refresh the network interfaces of a `Host` object. This includes options to ignore instantiation flags, extend the refresh to specific interface types like VLANs, and how the method updates the `network_interfaces` attribute.

```python
from mfd_typing.network_interface import InterfaceType
(...)
host.refresh_network_interfaces()  # to refresh host interfaces
(...)
host.refresh_network_interfaces(ignore_instantiate=True)  # to refresh all interfaces (including ones with 'instantiate' set to False)
(...)
host.network.vlan.create_vlan(vlan_id=100, interface_name="foo", vlan_name="foo_100") # to create VLAN interface
host.refresh_network_interfaces(extended=[InterfaceType.VLAN])  # to append foo_100 interface to list of network_interfaces
```

--------------------------------

### Display CPU Statistics (Linux)

Source: https://github.com/intel/mfd-host/blob/main/README.md

Displays CPU statistics for a Linux system. This function provides a textual representation of current CPU usage and other performance metrics.

```python
display_cpu_stats_only(self) -> str
```

--------------------------------

### Host Class - Refresh Network Interfaces

Source: https://github.com/intel/mfd-host/blob/main/README.md

The `refresh_network_interfaces` method updates the list of network interfaces on the host. Its behavior can be modified using `ignore_instantiate` and `extended` parameters to control which interfaces are refreshed and whether new ones like VFs are included.

```APIDOC
## Host.refresh_network_interfaces

### Description
Updates the list of `NetworkInterface` objects stored in the `self.network_interfaces` attribute. The method's behavior varies based on used flags or passed topology data.

### Method
`refresh_network_interfaces(ignore_instantiate: bool = False, extended: List[InterfaceType]] = None) -> None`

### Parameters
#### Path Parameters
None

#### Query Parameters
- **ignore_instantiate** (bool) - Optional - If True, all interfaces mentioned in the topology model will be refreshed, regardless of the 'instantiate' flag value. Defaults to False.
- **extended** (List[InterfaceType]) - Optional - A list of `InterfaceType` objects that should also be refreshed. Useful for including interfaces like VFs.

### Request Example
```python
# Example 1: Default refresh (only interfaces with 'instantiate' flag set)
host.refresh_network_interfaces()

# Example 2: Refresh all interfaces regardless of 'instantiate' flag
host.refresh_network_interfaces(ignore_instantiate=True)

# Example 3: Refresh VLAN interfaces in addition to default ones
host.refresh_network_interfaces(extended=[InterfaceType.VLAN])

# Example 4: Refresh all interfaces and also VFs
host.refresh_network_interfaces(ignore_instantiate=True, extended=[InterfaceType.VF])
```

### Response
#### Success Response (200)
None (This method updates an internal attribute and does not return a value).

#### Response Example
None
```

--------------------------------

### Find Devices (Windows)

Source: https://github.com/intel/mfd-host/blob/main/README.md

Finds devices currently attached to a Windows computer based on a device ID and a pattern. This function is used for device enumeration and identification.

```python
find_devices(device_id: str, pattern: str):
```

--------------------------------

### Restart System Service (Linux)

Source: https://github.com/intel/mfd-host/blob/main/README.md

Restarts a specified system service by its name on a Linux machine. This is a common operation for managing system daemons and ensuring services are running correctly.

```python
restart_service(name: str):
```

--------------------------------

### Set NUMA Affinity (ESXi)

Source: https://github.com/intel/mfd-host/blob/main/README.md

Sets the NUMA affinity for processes or threads in an ESXi environment by configuring the 'LocalityWeightActionAffinity' advanced setting. This can be used to optimize memory access patterns.

```python
set_numa_affinity(self, numa_state: State) -> None
```

--------------------------------

### Git Commit Signing

Source: https://github.com/intel/mfd-host/blob/main/CONTRIBUTING.md

This snippet shows the standard format for signing off on a git commit. It's used to certify that you have the right to submit the contribution under the project's open-source license. This is typically added to the end of a commit message.

```git
Signed-off-by: Joe Smith <joe.smith@email.com>
```

--------------------------------

### Enable Devices (Windows)

Source: https://github.com/intel/mfd-host/blob/main/README.md

Enables specified devices on a Windows computer. This function can be used to activate devices that have been previously disabled. A reboot option is available.

```python
enable_devices(device_id: str, pattern: str, reboot: bool):
```

--------------------------------

### Set Processor Group Size (Windows)

Source: https://github.com/intel/mfd-host/blob/main/README.md

Sets the maximum processor group size for systems with a large number of cores on Windows. This helps in managing processor allocation and can impact performance characteristics.

```python
set_groupsize(self, maxsize: int) -> None
```

--------------------------------

### Restart Devices (Windows)

Source: https://github.com/intel/mfd-host/blob/main/README.md

Stops and restarts specified devices on a Windows computer. This can be used to refresh device states or resolve temporary issues. A reboot option is available.

```python
restart_devices(device_id: str, pattern: str, reboot: bool):
```

--------------------------------

### Uninstall Devices (Windows)

Source: https://github.com/intel/mfd-host/blob/main/README.md

Removes a specified device from the device tree and deletes its device stack on a Windows system. It can optionally trigger a reboot after uninstallation.

```python
uninstall_devices(device_id: str, pattern: str, reboot: bool):
```

--------------------------------

### Set NetworkManager State (Linux)

Source: https://github.com/intel/mfd-host/blob/main/README.md

Enables or disables the NetworkManager service on a Linux system. This allows programmatic control over network management functionality.

```python
set_network_manager(*, enable: bool):
```

--------------------------------

### Check if Service is Running (Linux)

Source: https://github.com/intel/mfd-host/blob/main/README.md

Checks if a specified system service is currently running and active on a Linux system. Returns a boolean value indicating the service status.

```python
is_service_running(name: str):
```

--------------------------------

### Check Hyperthreading State (Windows)

Source: https://github.com/intel/mfd-host/blob/main/README.md

Checks the hyperthreading status on Windows systems. It returns the current state, indicating whether hyperthreading is enabled or disabled. This is useful for performance tuning and diagnostics.

```python
get_hyperthreading_state(self) -> State
```

--------------------------------

### Stop irqbalance Service (Linux)

Source: https://github.com/intel/mfd-host/blob/main/README.md

Stops or kills the irqbalance service if it is currently running on a Linux system. This can be necessary for manual IRQ affinity management.

```python
stop_irqbalance():
```

--------------------------------

### Check NetworkManager Status (Linux)

Source: https://github.com/intel/mfd-host/blob/main/README.md

Checks the status of the NetworkManager service specifically on a Linux system. This function is useful for network troubleshooting and management.

```python
is_network_manager_running():
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.