Round system RAM and HDD bytes, UP to nearest even gigabyte. Python

I'm collecting the system information of the current machine. Part of this information is the RAM and HDD capacity. Problem is that the capacity being gathered is measured in bytes rather than GB.

In a nutshell, how do I convert the display of the internal specifications to resemble what you would see from a consumer/commercial stand point?

1000GB HDD or 8GB RAM as opposed to the exact number of bytes available. Especially since manufacturers set aside different amounts of recovery sectors, RAM can be used for integrated graphics and the 1000 vs 1024 binary differential, etc... Here's an example of my current code:

import os
import wmi #import native powershell functionality
import math

c = wmi.WMI()  
SYSINFO = c.Win32_ComputerSystem()[0]    # Manufacturer/Model/Spec blob

RAMTOTAL = int(SYSINFO.TotalPhysicalMemory)        # Gathers only the RAM capacity in bytes.
RAMROUNDED = math.ceil(RAMTOTAL / 2000000000.) * 2.000000000        # attempts to round bytes to nearest, even, GB.
HDDTOTAL = int(HDDINFO.size) # Gathers only the HDD capacity in bytes.
HDDROUNDED = math.ceil(HDDTOTAL / 2000000000.) * 2.000000000        # attempts to round bytes to nearest, even, GB.
HDDPRNT = "HDD: " + str(HDDROUNDED) + "GB"
RAMPRNT = "RAM: " + str(RAMROUNDED) + "GB"
print(HDDPRNT)
print(RAMPRNT)

The area of interest is lines 8-11where I'm rounding up to the nearest even number since the internal size of RAM/HDD are always lower than advertised for reasons mentioned previously. StackOverflow posts have gotten me this method which is the most accurate, across the most machines, but it's still hard coded. Meaning the HDD only rounds accurately for either hundreds of GB or thousands, not both. Also, the RAM isn't 100% accurate.

Here's a couple workarounds that come to mind that will produce the results I'm looking for:

Adding additional commands to RAMTOTAL that may or may not be available. Allowing for GB output instead of KB. However. I would prefer it to be apart of the WMI import instead of straight native Windows code.
Figure out a more static method of rounding. ie: if HDDTOTAL > 1TB round up to decimal point X. else HDDTOTAL < 1TB use different rounding method.

Solution

I used a combination of the two previous suggestions.

I used an if loop, rather than a while loop, but get the same results. I also mirrored the same internal process of the suggested powershell commands to keep the script more native to python and without adding modules/dependencies.

GBasMB = int(1000000000) # Allows for accurate Bytes to GB conversion

global RAMSTRROUNDED
RAMTOTAL = int(SYSINFO.TotalPhysicalMemory) / (GBasMB) # Outputs GB by dividing by previous MB variable
RAMROUNDED = math.ceil(RAMTOTAL / 2.) * 2 # Rounds up to nearest even whole number
RAMSTRROUNDED = int(RAMROUNDED) # final converted variable

HDDTOTAL = int(HDDINFO.size) / (GBasMB) # Similar process as before for HardDrive
HDDROUNDED = math.ceil(HDDTOTAL / 2.) * 2 # round up to nearest even whole number

def ROUNDHDDTBORGB(): # function for determining TB or GB sized HDD
    global HDDTBORGBOUTPUT
    global HDDPRNT
    if HDDROUNDED >= 1000: # if equal to or greater than 1000GB, list as 1TB
        HDDTBORGB = HDDROUNDED * .001
        HDDTBORGBOUTPUT = str(HDDTBORGB) + "TB"
        HDDPRNT = "HDD: " + str(HDDTBORGBOUTPUT)
        print(HDDPRNT)
    elif HDDROUNDED < 1000: # if less than 1000GB list as GB
        HDDTBORGBOUTPUT = str(str(HDDROUNDED) + "GB")
        HDDPRNT = "HDD: " + str(HDDTBORGBOUTPUT)

I've ran this script on several dozen computers and seems to accurately gather the appropriate amount of RAM and HDD capacities. Regardless of how much RAM the integrated graphics decides to consume and/or reserve sectors on the HDD, etc...