hwdetect 1.0.0__tar.gz

hwdetect-1.0.0/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: hwdetect
+Version: 1.0.0
+Summary: A hybrid C/Python hardware detection package.
+Author: codingmaster24
+Dynamic: author
+Dynamic: summary

hwdetect-1.0.0/README.md

@@ -0,0 +1,31 @@
+sudo apt update
+sudo apt install python3-pip
+
+python3 -m pip install -e .
+
+pip3 install -e .
+
+# Install the package locally in editable mode (great for testing)
+pip install -e .
+
+# OR install it normally
+pip install .
+
+hwdetect
+
+# 1. Create a virtual environment named "venv"
+python3 -m venv venv
+
+# 2. Activate the virtual environment
+source venv/bin/activate
+
+# 3. Now install your package
+pip install -e .
+
+sudo apt install python3.14-venv
+
+python3 -m venv venv
+
+source venv/bin/activate
+
+pip install -e .

hwdetect-1.0.0/hwdetect/hardware_detect_base.c

@@ -0,0 +1,180 @@
+/* 
+ * hardware_detect_base.c
+ * Compile: gcc -O2 hardware_detect_base.c -o hardware_detect_base
+ * Run:     ./hardware_detect_base
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <cpuid.h>
+#include <sys/utsname.h>
+#include <sys/sysinfo.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <dirent.h>
+
+// Helper to read sysfs/proc text files safely
+void read_sysfs_value(const char *path, char *buffer, size_t max_len) {
+    int fd = open(path, O_RDONLY);
+    if (fd < 0) {
+        snprintf(buffer, max_len, "N/A (Requires Root or Unsupported)");
+        return;
+    }
+    ssize_t bytes = read(fd, buffer, max_len - 1);
+    if (bytes > 0) {
+        buffer[bytes] = '\0';
+        // Strip trailing newline
+        char *newline = strchr(buffer, '\n');
+        if (newline) *newline = '\0';
+    } else {
+        snprintf(buffer, max_len, "N/A");
+    }
+    close(fd);
+}
+
+// 1. CPU Detection using x86 CPUID Assembly & Standard Headers
+void detect_cpu() {
+    printf("========================================\n");
+    printf("            CPU CONFIGURATION           \n");
+    printf("========================================\n");
+
+    unsigned int eax, ebx, ecx, edx;
+
+    // CPU Vendor String (Leaf 0x00000000)
+    char vendor[13] = {0};
+    __cpuid(0, eax, ebx, ecx, edx);
+    *(unsigned int *)&vendor[0] = ebx;
+    *(unsigned int *)&vendor[4] = edx;
+    *(unsigned int *)&vendor[8] = ecx;
+    printf("CPU Vendor      : %s\n", vendor);
+
+    // CPU Brand String via Assembly (Leaves 0x80000002, 0x80000003, 0x80000004)
+    char brand[49] = {0};
+    unsigned int *bptr = (unsigned int *)brand;
+    for (unsigned int leaf = 0x80000002; leaf <= 0x80000004; ++leaf) {
+        __cpuid(leaf, eax, ebx, ecx, edx);
+        *bptr++ = eax;
+        *bptr++ = ebx;
+        *bptr++ = ecx;
+        *bptr++ = edx;
+    }
+    printf("CPU Model       : %s\n", brand[0] ? brand : "Unknown");
+
+    // Cores and Threads from system headers
+    long proc_online = sysconf(_SC_NPROCESSORS_ONLN);
+    long proc_conf   = sysconf(_SC_NPROCESSORS_CONF);
+    printf("Logical Threads : %ld\n", proc_online);
+    printf("Configured Cores: %ld\n", proc_conf);
+}
+
+// 2. RAM Detection using <sys/sysinfo.h> & /proc/meminfo
+void detect_ram() {
+    printf("\n========================================\n");
+    printf("            RAM CONFIGURATION           \n");
+    printf("========================================\n");
+
+    struct sysinfo si;
+    if (sysinfo(&si) == 0) {
+        unsigned long total_ram = (si.totalram * si.mem_unit) / (1024 * 1024);
+        unsigned long free_ram  = (si.freeram * si.mem_unit) / (1024 * 1024);
+        unsigned long avail_ram = (si.freeram + si.bufferram) * si.mem_unit / (1024 * 1024);
+
+        printf("Total Memory    : %lu MB (%.2f GB)\n", total_ram, total_ram / 1024.0);
+        printf("Free Memory     : %lu MB\n", free_ram);
+        printf("Available Memory: %lu MB\n", avail_ram);
+    }
+
+    // Module Specs via DMI Sysfs
+    char ram_type[64], ram_speed[64];
+    read_sysfs_value("/sys/class/dmi/id/memory_device_type", ram_type, sizeof(ram_type));
+    read_sysfs_value("/sys/class/dmi/id/memory_device_speed", ram_speed, sizeof(ram_speed));
+    printf("DMI Memory Type : %s\n", ram_type);
+    printf("DMI Speed       : %s\n", ram_speed);
+}
+
+// 3. Motherboard Detection via Sysfs DMI tables
+void detect_motherboard() {
+    printf("\n========================================\n");
+    printf("        MOTHERBOARD CONFIGURATION       \n");
+    printf("========================================\n");
+
+    char vendor[128], product[128], version[128], bios_ver[128];
+    read_sysfs_value("/sys/class/dmi/id/board_vendor", vendor, sizeof(vendor));
+    read_sysfs_value("/sys/class/dmi/id/board_name", product, sizeof(product));
+    read_sysfs_value("/sys/class/dmi/id/board_version", version, sizeof(version));
+    read_sysfs_value("/sys/class/dmi/id/bios_version", bios_ver, sizeof(bios_ver));
+
+    printf("Manufacturer    : %s\n", vendor);
+    printf("Board Model     : %s\n", product);
+    printf("Board Revision  : %s\n", version);
+    printf("BIOS Version    : %s\n", bios_ver);
+}
+
+// 4. GPU Detection via PCI Bus Scanning (/sys/bus/pci/devices)
+void detect_gpu() {
+    printf("\n========================================\n");
+    printf("            GPU CONFIGURATION           \n");
+    printf("========================================\n");
+
+    DIR *dir = opendir("/sys/bus/pci/devices");
+    if (!dir) {
+        printf("Cannot access PCI bus.\n");
+        return;
+    }
+
+    struct dirent *entry;
+    int count = 0;
+    while ((entry = readdir(dir)) != NULL) {
+        if (entry->d_name[0] == '.') continue;
+
+        char class_path[512], class_buf[32] = {0};
+        snprintf(class_path, sizeof(class_path), "/sys/bus/pci/devices/%s/class", entry->d_name);
+        read_sysfs_value(class_path, class_buf, sizeof(class_buf));
+
+        // Display Controller Class Prefix: 0x030000 (VGA) or 0x030200 (3D Controller)
+        if (strncmp(class_buf, "0x03", 4) == 0) {
+            count++;
+            char vendor_path[512], device_path[512];
+            char vendor_id[32] = {0}, device_id[32] = {0};
+
+            snprintf(vendor_path, sizeof(vendor_path), "/sys/bus/pci/devices/%s/vendor", entry->d_name);
+            snprintf(device_path, sizeof(device_path), "/sys/bus/pci/devices/%s/device", entry->d_name);
+            read_sysfs_value(vendor_path, vendor_id, sizeof(vendor_id));
+            read_sysfs_value(device_path, device_id, sizeof(device_id));
+
+            printf("[GPU #%d]\n", count);
+            printf("  PCI Slot ID   : %s\n", entry->d_name);
+            printf("  Vendor ID     : %s\n", vendor_id);
+            printf("  Device ID     : %s\n", device_id);
+            printf("  Device Class  : %s\n", class_buf);
+        }
+    }
+    closedir(dir);
+    if (count == 0) printf("No PCI Display Adapters found.\n");
+}
+
+// 5. Operating System Specifications using <sys/utsname.h>
+void detect_os() {
+    printf("\n========================================\n");
+    printf("            OS & KERNEL SPEC            \n");
+    printf("========================================\n");
+
+    struct utsname os_info;
+    if (uname(&os_info) == 0) {
+        printf("OS Kernel Name  : %s\n", os_info.sysname);
+        printf("Node Hostname   : %s\n", os_info.nodename);
+        printf("Kernel Release  : %s\n", os_info.release);
+        printf("Kernel Version  : %s\n", os_info.version);
+        printf("Architecture    : %s\n", os_info.machine);
+    }
+}
+
+int main() {
+    detect_os();
+    detect_cpu();
+    detect_ram();
+    detect_motherboard();
+    detect_gpu();
+    return 0;
+}

hwdetect-1.0.0/hwdetect/hardware_detect_base_py.py

@@ -0,0 +1,154 @@
+import os
+import glob
+import ctypes
+import struct
+
+def read_file(path):
+    try:
+        with open(path, "r") as f:
+            return f.read().strip()
+    except Exception:
+        return "N/A"
+
+# 1. OS & Kernel (via C libc uname call)
+class UNameStruct(ctypes.Structure):
+    _fields_ = [
+        ('sysname', ctypes.c_char * 65),
+        ('nodename', ctypes.c_char * 65),
+        ('release', ctypes.c_char * 65),
+        ('version', ctypes.c_char * 65),
+        ('machine', ctypes.c_char * 65),
+        ('domainname', ctypes.c_char * 65)
+    ]
+
+def detect_os():
+    print("=" * 45)
+    print("            OS & KERNEL SPEC             ")
+    print("=" * 45)
+    try:
+        libc = ctypes.CDLL("libc.so.6")
+        buf = UNameStruct()
+        if libc.uname(ctypes.byref(buf)) == 0:
+            print(f"OS Kernel Name  : {buf.sysname.decode()}")
+            print(f"Hostname        : {buf.nodename.decode()}")
+            print(f"Kernel Release  : {buf.release.decode()}")
+            print(f"Architecture    : {buf.machine.decode()}")
+    except Exception as e:
+        print(f"Could not execute libc.uname: {e}")
+
+# 2. CPU Specs (Reading raw CPU brand/topology from kernel sysfs)
+def detect_cpu():
+    print("\n" + "=" * 45)
+    print("            CPU CONFIGURATION            ")
+    print("=" * 45)
+    
+    # Read model name from sysfs/proc directly
+    cpu_model = "Unknown"
+    if os.path.exists("/proc/cpuinfo"):
+        with open("/proc/cpuinfo", "r") as f:
+            for line in f:
+                if "model name" in line:
+                    cpu_model = line.split(":")[1].strip()
+                    break
+
+    logical_threads = os.cpu_count() or 0
+    
+    # Calculate physical cores by parsing core IDs
+    core_ids = set()
+    for cpu_dir in glob.glob("/sys/devices/system/cpu/cpu[0-9]*"):
+        core_id = read_file(f"{cpu_dir}/topology/core_id")
+        if core_id != "N/A":
+            core_ids.add(core_id)
+            
+    physical_cores = len(core_ids) if core_ids else "N/A"
+
+    print(f"CPU Model       : {cpu_model}")
+    print(f"Physical Cores  : {physical_cores}")
+    print(f"Logical Threads : {logical_threads}")
+
+# 3. RAM Specs (via libc sysinfo and /proc/meminfo)
+class SysInfoStruct(ctypes.Structure):
+    _fields_ = [
+        ('uptime', ctypes.c_long),
+        ('loads', ctypes.c_ulong * 3),
+        ('totalram', ctypes.c_ulong),
+        ('freeram', ctypes.c_ulong),
+        ('sharedram', ctypes.c_ulong),
+        ('bufferram', ctypes.c_ulong),
+        ('totalswap', ctypes.c_ulong),
+        ('freeswap', ctypes.c_ulong),
+        ('procs', ctypes.c_ushort),
+        ('totalhigh', ctypes.c_ulong),
+        ('freehigh', ctypes.c_ulong),
+        ('mem_unit', ctypes.c_uint)
+    ]
+
+def detect_ram():
+    print("\n" + "=" * 45)
+    print("            RAM CONFIGURATION            ")
+    print("=" * 45)
+    try:
+        libc = ctypes.CDLL("libc.so.6")
+        info = SysInfoStruct()
+        if libc.sysinfo(ctypes.byref(info)) == 0:
+            unit = info.mem_unit if info.mem_unit > 0 else 1
+            total_gb = (info.totalram * unit) / (1024 ** 3)
+            free_gb = (info.freeram * unit) / (1024 ** 3)
+            print(f"Total RAM       : {total_gb:.2f} GB")
+            print(f"Free RAM        : {free_gb:.2f} GB")
+    except Exception as e:
+        print(f"Error fetching memory via libc: {e}")
+
+    # Read RAM module hardware details from DMI tables
+    ram_type = read_file("/sys/class/dmi/id/memory_device_type")
+    ram_speed = read_file("/sys/class/dmi/id/memory_device_speed")
+    print(f"Memory Type     : {ram_type}")
+    print(f"Memory Speed    : {ram_speed}")
+
+# 4. Motherboard Specs
+def detect_motherboard():
+    print("\n" + "=" * 45)
+    print("        MOTHERBOARD CONFIGURATION        ")
+    print("=" * 45)
+    vendor = read_file("/sys/class/dmi/id/board_vendor")
+    product = read_file("/sys/class/dmi/id/board_name")
+    version = read_file("/sys/class/dmi/id/board_version")
+    bios = read_file("/sys/class/dmi/id/bios_version")
+
+    print(f"Manufacturer    : {vendor}")
+    print(f"Product Name    : {product}")
+    print(f"Board Revision  : {version}")
+    print(f"BIOS Version    : {bios}")
+
+# 5. GPU Specs (PCI Bus Scan via /sys/bus/pci/devices)
+def detect_gpu():
+    print("\n" + "=" * 45)
+    print("            GPU CONFIGURATION            ")
+    print("=" * 45)
+    gpu_devices = []
+    pci_devices = glob.glob("/sys/bus/pci/devices/*")
+    
+    for dev in pci_devices:
+        cls = read_file(f"{dev}/class")
+        # Match PCI class 0x030000 (VGA) or 0x030200 (3D Controller)
+        if cls.startswith("0x03"):
+            vendor_id = read_file(f"{dev}/vendor")
+            device_id = read_file(f"{dev}/device")
+            gpu_devices.append((dev.split("/")[-1], vendor_id, device_id, cls))
+
+    if gpu_devices:
+        for idx, (slot, vendor, device, dev_cls) in enumerate(gpu_devices, 1):
+            print(f"[GPU #{idx}]")
+            print(f"  PCI Bus Address: {slot}")
+            print(f"  Vendor ID      : {vendor}")
+            print(f"  Device ID      : {device}")
+            print(f"  Class Code     : {dev_cls}")
+    else:
+        print("No PCI GPU devices detected.")
+
+if __name__ == "__main__":
+    detect_os()
+    detect_cpu()
+    detect_ram()
+    detect_motherboard()
+    detect_gpu()

hwdetect-1.0.0/hwdetect/main.py

@@ -0,0 +1,52 @@
+import os
+import subprocess
+import logging
+from . import hardware_detect_base_py
+
+# Configure Logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    datefmt='%Y-%m-%d %H:%M:%S'
+)
+logger = logging.getLogger("HWDetect")
+
+def run_hardware_detect():
+    # Locate the directory where this package is installed
+    base_dir = os.path.dirname(os.path.abspath(__file__))
+    c_binary = os.path.join(base_dir, 'hardware_detect_base')
+
+    logger.info("Attempting to detect hardware using low-level C binary...")
+    
+    try:
+        if not os.path.exists(c_binary):
+            raise FileNotFoundError("C binary not found. It may have failed to compile during installation.")
+        
+        # Execute the C binary and capture the output
+        result = subprocess.run([c_binary], capture_output=True, text=True, check=True)
+        print(result.stdout)
+        logger.info("Hardware detection completed successfully using C binary.")
+        
+    except subprocess.CalledProcessError as e:
+        logger.warning(f"C binary executed but returned an error (Code {e.returncode}).")
+        logger.debug(f"C binary stderr: {e.stderr}")
+        _run_python_fallback()
+        
+    except Exception as e:
+        logger.warning(f"C binary execution failed: {e}")
+        _run_python_fallback()
+
+def _run_python_fallback():
+    logger.info("Falling back to Python-based hardware detection...")
+    try:
+        hardware_detect_base_py.detect_os()
+        hardware_detect_base_py.detect_cpu()
+        hardware_detect_base_py.detect_ram()
+        hardware_detect_base_py.detect_motherboard()
+        hardware_detect_base_py.detect_gpu()
+        logger.info("Hardware detection completed successfully using Python fallback.")
+    except Exception as e:
+        logger.error(f"Critical Failure: Python fallback also failed. Exception: {e}")
+
+if __name__ == "__main__":
+    run_hardware_detect()

hwdetect-1.0.0/hwdetect.egg-info/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: hwdetect
+Version: 1.0.0
+Summary: A hybrid C/Python hardware detection package.
+Author: codingmaster24
+Dynamic: author
+Dynamic: summary

hwdetect-1.0.0/hwdetect.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+setup.py
+hwdetect/__init__.py
+hwdetect/hardware_detect_base
+hwdetect/hardware_detect_base.c
+hwdetect/hardware_detect_base_py.py
+hwdetect/main.py
+hwdetect.egg-info/PKG-INFO
+hwdetect.egg-info/SOURCES.txt
+hwdetect.egg-info/dependency_links.txt
+hwdetect.egg-info/entry_points.txt
+hwdetect.egg-info/top_level.txt

hwdetect-1.0.0/hwdetect.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

hwdetect-1.0.0/hwdetect.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+hwdetect = hwdetect.main:run_hardware_detect

hwdetect-1.0.0/hwdetect.egg-info/top_level.txt

@@ -0,0 +1 @@
+hwdetect

hwdetect-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

hwdetect-1.0.0/setup.py

@@ -0,0 +1,41 @@
+import os
+import subprocess
+from setuptools import setup, find_packages
+from setuptools.command.build_py import build_py
+
+class CustomBuildCommand(build_py):
+    """Custom build command to compile the C source during pip install."""
+    def run(self):
+        # Paths for the C source and the output binary
+        c_source = os.path.join('hwdetect', 'hardware_detect_base.c')
+        c_binary = os.path.join('hwdetect', 'hardware_detect_base')
+        
+        try:
+            print(f"Compiling {c_source} using GCC...")
+            subprocess.check_call(['gcc', '-O2', c_source, '-o', c_binary])
+            print("C binary compiled successfully.")
+        except Exception as e:
+            print(f"WARNING: Failed to compile C source. The package will rely on the Python fallback. Error: {e}")
+            
+        # Continue with the standard Python package build process
+        super().run()
+
+setup(
+    name="hwdetect",
+    version="1.0.0",
+    description="A hybrid C/Python hardware detection package.",
+    author="codingmaster24",
+    packages=find_packages(),
+    # Ensure the compiled binary is included in the final package
+    package_data={'hwdetect': ['hardware_detect_base', 'hardware_detect_base.c']},
+    include_package_data=True,
+    cmdclass={
+        'build_py': CustomBuildCommand,
+    },
+    # This creates a terminal command you can run from anywhere
+    entry_points={
+        'console_scripts': [
+            'hwdetect=hwdetect.main:run_hardware_detect',
+        ],
+    },
+)