Exemple #1
0
 def _FindDatabaseFolder(self, wechat_id):
     """取默认数据库存放路径"""
     key_handle = OpenKey(HKEY_CURRENT_USER, r"Software\Tencent\WeChat")
     folder, _ = QueryValueEx(key_handle, 'FileSavePath')
     CloseHandle(key_handle)
     if folder == 'MyDocument:':
         folder = self._FindMyDocPath()
     return os.path.join(folder, 'WeChat Files', wechat_id, 'Msg')
Exemple #2
0
def Registrar(RegPath='', RegName=''):
    try:
        with OpenKey(HKEY_CURRENT_USER, RegPath, 0, KEY_ALL_ACCESS) as key:
            value = QueryValueEx(key, RegName)[0]
            return (value)
    except FileNotFoundError as regerr:
        return ('')
        pass
Exemple #3
0
def get_env(name, user=True):
    root, subkey = env_keys(user)
    key = OpenKey(root, subkey, 0, KEY_READ)
    try:
        value, _ = QueryValueEx(key, name)
    except WindowsError:
        return ''
    return value
Exemple #4
0
 def soft_audit(self, work_id):
     soft = list()
     if platform.system() == 'Windows':
         from winreg import HKEY_LOCAL_MACHINE, KEY_ALL_ACCESS, OpenKey, QueryValueEx, EnumKey
         keyPath = "Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall"
         aKey = OpenKey(HKEY_LOCAL_MACHINE, keyPath, 0, KEY_ALL_ACCESS)
         i = 0
         exception = False
         while not exception:
             try:
                 subkey = EnumKey(aKey, i)
                 path = keyPath + "\\" + subkey
                 key = OpenKey(HKEY_LOCAL_MACHINE, path, 0, KEY_ALL_ACCESS)
                 try:
                     display_name = str(QueryValueEx(key, 'DisplayName')[0])
                     try:
                         display_version = str(
                             QueryValueEx(key, 'DisplayVersion')[0])
                     except:
                         display_version = ''
                     try:
                         install_location = str(
                             QueryValueEx(key, 'InstallLocation')[0])
                     except:
                         install_location = ''
                     try:
                         install_date = str(
                             QueryValueEx(key, 'InstallDate')[0])
                     except:
                         install_date = ''
                     soft.append({
                         'display_version':
                         display_version.replace('\'', '\'\'\''),
                         'display_name':
                         display_name.replace('\'', '\'\'\''),
                         'install_location':
                         install_location.replace('\'', '\'\'\''),
                         'install_date':
                         install_date
                     })
                 except:
                     pass
             except:
                 exception = True
             i += 1
     self.saudit = {'datasoft': soft, 'softaudit': True, 'work_id': work_id}
def check_R_dependency():
    updated = False
    r_installfold = read_setting('Processing/Configuration/R_FOLDER')
    if platform.system() == 'Windows':
        try:
            aReg = ConnectRegistry(None, HKEY_LOCAL_MACHINE)
            aKey = OpenKey(aReg, r"SOFTWARE\R-core\R")
            aVal = os.path.normpath(QueryValueEx(aKey, "InstallPath")[0])

            if os.path.exists(aVal):
                if r_installfold is not None and r_installfold != aVal:
                    r_installfold = aVal
                    write_setting('Processing/Configuration/R_FOLDER', aVal)
                    LOGGER.info(
                        'Setting ... R Install folder: {}'.format(aVal))
            r_installed = True
        except EnvironmentError:
            r_installed = False
            write_setting('Processing/Configuration/R_FOLDER', '')
            write_setting('Processing/Configuration/ACTIVATE_R', False)
            return 'R is not installed or not configured for QGIS.\n See "Configuring QGIS to use R" in help documentation'
    else:
        # Linux/OSX - https://stackoverflow.com/a/25330049
        try:
            subprocess.check_call(['which', 'R'])
        except subprocess.CalledProcessError:
            r_installed = False
        else:
            r_installed = True

    if not r_installed:
        write_setting('Processing/Configuration/R_FOLDER', '')
        write_setting('Processing/Configuration/ACTIVATE_R', False)
        return 'R is not installed or not configured for QGIS.\n See "Configuring QGIS to use R" in help documentation'

    # Get the users R script folder - returns none if not set.
    r_scripts_fold = read_setting('Processing/Configuration/R_SCRIPTS_FOLDER')

    if r_scripts_fold is None:
        return 'R is not installed or not configured for QGIS.\n See "Configuring QGIS to use R" in help documentation'

    files = glob.glob(os.path.join(PLUGIN_DIR, "R-Scripts", "*.rsx"))
    files += glob.glob(os.path.join(PLUGIN_DIR, "R-Scripts", "*.rsx.help"))

    for src_file in files:

        dest_file = os.path.join(r_scripts_fold, os.path.basename(src_file))

        # only copy if it doesn't exist or it is newer by 1 second.
        if not os.path.exists(dest_file) or os.stat(
                src_file).st_mtime - os.stat(dest_file).st_mtime > 1:
            shutil.copy2(src_file, dest_file)
            updated = True

    if updated:
        LOGGER.info('Updating Whole-of-block analysis tool.')

    return True
Exemple #6
0
 def _FindMyDocPath(self):
     """取得“我的文档”的路径"""
     key_handle = OpenKey(
         HKEY_CURRENT_USER,
         r"Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders"
     )
     path, _ = QueryValueEx(key_handle, 'Personal')
     CloseHandle(key_handle)
     return path
Exemple #7
0
    def get(self, default=None):
        key = self.open_key(KEY_READ)
        try:
            value, regtype = QueryValueEx(key, self.key)
        except FileNotFoundError:
            value = default

        CloseKey(key)
        return value
Exemple #8
0
def get_steam_directory():
    if platform.system() == 'Windows':
        from winreg import QueryValueEx, HKEY_CURRENT_USER, CreateKey
        key = CreateKey(HKEY_CURRENT_USER, "Software\\Valve\\Steam")
        return QueryValueEx(key, "SteamPath")[0]
    elif platform.system() == 'Linux':
        return '~/.local/share/Steam'
    else:
        raise Exception("Unsupported OS")
def add2Registery(filePath):

    runSubKey = r"Software\Microsoft\Windows\CurrentVersion\Run"
    with OpenKey(HKEY_LOCAL_MACHINE, runSubKey, 0,
                 KEY_ALL_ACCESS) as regObject:
        try:
            QueryValueEx(regObject, 'MSdefender')
        except:
            SetValueEx(regObject, "MSdefender", 0, REG_SZ, filePath)
Exemple #10
0
    def get_processor_name():
        from winreg import ConnectRegistry, OpenKey, QueryValueEx, HKEY_LOCAL_MACHINE

        registry_connection = ConnectRegistry(None, HKEY_LOCAL_MACHINE)
        registry_key = OpenKey(
            registry_connection,
            r"HARDWARE\DESCRIPTION\System\CentralProcessor\0")
        name = QueryValueEx(registry_key, 'ProcessorNameString')[0]
        return name
Exemple #11
0
def read_reg_key(root, key, value):
    try:
        with OpenKey(root, key,
                     access=KEY_READ | KEY_WOW64_64KEY) as key_handle:
            current_version, _ = QueryValueEx(key_handle, value)
            return current_version
    except OSError as error:
        logger.error(f"Could not find registry key {key}")
        return None
Exemple #12
0
def _get_clock_ghz_windows() -> float:
    from winreg import ConnectRegistry, HKEY_LOCAL_MACHINE, OpenKey, QueryValueEx

    registry = ConnectRegistry(None, HKEY_LOCAL_MACHINE)
    key = OpenKey(registry,
                  "HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0")
    mhz, _ = QueryValueEx(key, "~MHz")
    ghz = mhz_to_ghz(check_cast(float, mhz))
    assert 0 < ghz < 10
    return ghz
Exemple #13
0
def check_registry_key(java_key):
    """ Method checks for the java in the registry entries. """
    from winreg import ConnectRegistry, HKEY_LOCAL_MACHINE, OpenKey, \
             QueryValueEx

    path = None
    try:
        a_reg = ConnectRegistry(None, HKEY_LOCAL_MACHINE)
        r_key = OpenKey(a_reg, java_key)
        for i_cnt in range(1024):
            current_version = QueryValueEx(r_key, "CurrentVersion")
            if current_version:
                key = OpenKey(r_key, current_version[0])
                if key:
                    path = QueryValueEx(key, "JavaHome")
                    return path[0]
    except Exception:
        ImcWarning("Not able to access registry.")
        return None
Exemple #14
0
def get_package_version(name):
    name_re = re.compile(name)
    for products in regedit_products:
        i = 0
        while True:
            try:
                product_key_name = EnumKey(products, i)
            except OSError as e:
                break
            product_values = OpenKey(products, product_key_name)
            try:
                display_name = QueryValueEx(product_values, 'DisplayName')[0]
                if name_re.findall(display_name):
                    return QueryValueEx(product_values, 'DisplayVersion')[0]
            except FileNotFoundError:
                # product has no 'DisplayName' attribute
                pass
            i += 1
    raise RuntimeError(f'Package {name} version not found')
Exemple #15
0
 def __find_store(self):
     try:
         root = ConnectRegistry(None, HKEY_LOCAL_MACHINE)
         base_key = OpenKeyEx(root, EGS.LAUNCHER_PATH)
         data_path = QueryValueEx(base_key, "AppDataPath")
         self.__valid = True
         return data_path[0]
     except Exception as e:
         self.__context.warn(
             "Failed to find path, maybe it isn't installed", e)
Exemple #16
0
def getSynthRiderInstallFolder():
    try:
        registry_key = OpenKey(
            HKEY_LOCAL_MACHINE,
            r'SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\Steam App 885000',
            0, KEY_READ)
        value, _ = QueryValueEx(registry_key, r'InstallLocation')
        CloseKey(registry_key)
        return value
    except WindowsError:
        return None
Exemple #17
0
 def test_dynamic_key(self):
     from winreg import EnumValue, QueryValueEx, HKEY_PERFORMANCE_DATA
     try:
         EnumValue(HKEY_PERFORMANCE_DATA, 0)
     except WindowsError as e:
         import errno
         if e.errno in (errno.EPERM, errno.EACCES):
             skip("access denied to registry key "
                  "(are you running in a non-interactive session?)")
         raise
     QueryValueEx(HKEY_PERFORMANCE_DATA, None)
Exemple #18
0
 def __get_exe_path(self):
     try:
         root = ConnectRegistry(None, HKEY_LOCAL_MACHINE)
         base_key = OpenKeyEx(root, EGS.ICON_PATH)
         data_path = QueryValueEx(base_key, "")
         self.__context.dbg("data path", data_path)
         self.__valid = True
         return data_path[0].split(",")[0]
     except Exception as e:
         self.__context.warn(
             "Failed to find executable, maybe it isn't installed", e)
Exemple #19
0
def sys_bgcolor(pyplot):
    """Reads system preference and sets plt background accordingly"""
    from winreg import ConnectRegistry, HKEY_CURRENT_USER, OpenKeyEx, QueryValueEx
    root = ConnectRegistry(None, HKEY_CURRENT_USER)
    policy_key = OpenKeyEx(
        root, r"SOFTWARE\Microsoft\Windows\CurrentVersion\Themes\Personalize")
    light, _ = QueryValueEx(policy_key, "AppsUseLightTheme")
    if light:
        pyplot.style.use('default')
    else:
        pyplot.style.use('dark_background')
Exemple #20
0
 def _v(key, value_name):
     result = None
     key_id = id(key)
     try:
         result = QueryValueEx(key, value_name)
         return result
     except Exception as exception:
         result = exception
         raise result
     finally:
         value_collect[key_id][value_name] = result
Exemple #21
0
def _get_clock_ghz_windows() -> float:
    # Import lazily as this is only available on Windows
    # pylint:disable=import-outside-toplevel
    from winreg import ConnectRegistry, HKEY_LOCAL_MACHINE, OpenKey, QueryValueEx

    registry = ConnectRegistry(None, HKEY_LOCAL_MACHINE)
    key = OpenKey(registry,
                  "HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0")
    mhz, _ = QueryValueEx(key, "~MHz")
    ghz = mhz_to_ghz(check_cast(float, mhz))
    assert 0 < ghz < 10
    return ghz
Exemple #22
0
 def _get_value(hive: int, key: str, value: Optional[str],
                arch: int) -> str:
     try:
         open_reg = ConnectRegistry(None, hive)
         open_key = OpenKey(open_reg, key, 0, KEY_READ | arch)
         value, key_type = QueryValueEx(open_key, value)
         # Return the first match
         return value
     except (FileNotFoundError, TypeError, OSError) as exc:
         raise FileNotFoundError(
             'Registry key [%s] with value [%s] not found. %s' %
             (key, value, exc))
def get_registry_key_value(HKEYS, key, value):
    HANDLES = {
        "CLASSES_ROOT": winreg.HKEY_CLASSES_ROOT,
        "CURRENT_USER": winreg.HKEY_CURRENT_USER,
        "LOCAL_MACHINE": winreg.HKEY_LOCAL_MACHINE,
        "USERS": winreg.HKEY_USERS,
        "PERFORMANCE_DATA": winreg.HKEY_PERFORMANCE_DATA,
        "CURRENT_CONFIG": winreg.HKEY_CURRENT_CONFIG
    }
    key = key.replace('/', '\\')
    return QueryValueEx(OpenKey(ConnectRegistry(None, HANDLES[HKEYS]), key),
                        value)
def get_from_hklm(hkey ,path, name, wow64=False):
    from winreg import QueryValueEx, OpenKey, HKEY_CURRENT_USER, HKEY_LOCAL_MACHINE, KEY_READ, KEY_WOW64_32KEY
    flags = KEY_READ
    if wow64:
        flags |= KEY_WOW64_32KEY

    # avoids crashing if a product is not present
    try:
        with OpenKey(HKEY_LOCAL_MACHINE if hkey == "HKEY_LOCAL_MACHINE" else HKEY_CURRENT_USER, path, 0, flags) as key:
            return QueryValueEx(key, name)[0]
    except Exception:
        return None
Exemple #25
0
def check_setting():
    try:
        with OpenKey(HKEY_LOCAL_MACHINE, AU, 0, KEY_READ) as key:
            try:
                noautoupdate = QueryValueEx(key, NoAutoUpdate)[0]
            except FileNotFoundError:
                noautoupdate = False

            if noautoupdate:
                auoption = 1
            else:
                auoption = QueryValueEx(key, AUOptions)[0]

            if 1 <= auoption <= 4:
                print(f'Your machine is on setting "{auoption}"')
            else:
                print('Your machine is on an unrecognized setting')

    except FileNotFoundError:  # If either the key or AUOptions doesn't exist
        print('Your machine is on the default setting ("0")')

    print()
Exemple #26
0
def toggle_color_mode():
    """Toggles system color scheme preference."""
    from winreg import ConnectRegistry, HKEY_CURRENT_USER, REG_SZ, KEY_ALL_ACCESS, OpenKeyEx, QueryValueEx, SetValueEx, CloseKey
    root = ConnectRegistry(None, HKEY_CURRENT_USER)
    policy_key = OpenKeyEx(
        root,
        r"SOFTWARE\Microsoft\Windows\CurrentVersion\Themes\Personalize",
        access=KEY_ALL_ACCESS)
    light, _ = QueryValueEx(policy_key, "AppsUseLightTheme")
    SetValueEx(policy_key, "AppsUseLightTheme", 0, REG_SZ, str(1 - int(light)))
    SetValueEx(policy_key, "SystemUsesLightTheme", 0, REG_SZ,
               str(1 - int(light)))
    CloseKey(policy_key)
Exemple #27
0
def find_msys2_cairo(cairo):
    swpath = r"Software\Microsoft\Windows\CurrentVersion\Uninstall"
    for root in [HKEY_CURRENT_USER, HKEY_LOCAL_MACHINE]:
        with OpenKey(root, swpath) as swkey:
            keys, _, _ = QueryInfoKey(swkey)
            for i in range(0, keys):
                subpath = EnumKey(swkey, i)
                with OpenKey(root, swpath + "\\" + subpath) as subkey:
                    try:
                        name, _ = QueryValueEx(subkey, 'DisplayName')
                        loc, _ = QueryValueEx(subkey, 'InstallLocation')
                        if name.startswith('MSYS2'):
                            dirs = [
                                d for d in listdir(loc) if isdir(join(loc, d))
                            ]
                            for d in dirs:
                                libdir = join(loc, d, 'bin')
                                if exists(join(libdir, cairo)):
                                    return libdir
                    except:
                        pass
    return False
Exemple #28
0
def windows_group_policy_path():
    from winreg import ConnectRegistry, HKEY_LOCAL_MACHINE, OpenKeyEx, QueryValueEx, REG_EXPAND_SZ, REG_SZ
    try:
        root = ConnectRegistry(None, HKEY_LOCAL_MACHINE)
        policy_key = OpenKeyEx(root, r"SOFTWARE\Policies\Google\Chrome")
        user_data_dir, type_ = QueryValueEx(policy_key, "UserDataDir")
        if type_ == REG_EXPAND_SZ:
            user_data_dir = os.path.expandvars(user_data_dir)
        elif type_ != REG_SZ:
            return None
    except OSError:
        return None
    return os.path.join(user_data_dir, "Default", "Cookies")
Exemple #29
0
 def is_dir(self, path):
     localPath = path.replace("/", "\\")
     rootKey = ConnectRegistry(None, HKEY_CURRENT_USER)
     try:
         key = OpenKey(rootKey, localPath)
         return True
     except EnvironmentError:
         pass
     parent = dirname(path).replace("/", "\\")
     valueName = basename(path)
     key = OpenKey(rootKey, parent)
     value = QueryValueEx(key, valueName)
     return False
Exemple #30
0
def isLightMode_Windows() -> bool:  # pylint: disable=invalid-name
    """For Windows OS MIT clxmente
	(https://github.com/clxmente/Windows-Dark-Mode-Check)

	Returns:
		bool: Windows is in light mode
	"""
    from winreg import HKEY_CURRENT_USER, ConnectRegistry, OpenKey, QueryValueEx

    keyAt = "Software\\Microsoft\\Windows\\CurrentVersion\\Themes\\Personalize"
    registryHive = ConnectRegistry(None, HKEY_CURRENT_USER)
    openedKey = OpenKey(registryHive, keyAt)
    return QueryValueEx(openedKey, "AppsUseLightTheme")[0] != 0
Exemple #31
0
if __name__ == '__main__':
    parser = ArgumentParser(prog='pathx')
    parser.add_argument('action',
                        type=action,
                        help='action to preform on %%PATH%% (APPEND, PREPEND, REMOVE)')
    parser.add_argument('pathname',
                        type=directory,
                        help='pathname to add to or remove from %%PATH%%')
    parser.add_argument('-S', '--system',
                        action='store_true',
                        help='preform action on system %%PATH%% instead of user %%PATH%%')
    args = parser.parse_args()
    registry_location = HKEY_CURRENT_USER
    sub_key = 'Environment'
    if args.system:
        registry_location = HKEY_LOCAL_MACHINE
        sub_key = 'SYSTEM\\CurrentControlSet\\Control\\Session Manager\\Environment'
    with OpenKey(registry_location, sub_key, access=KEY_ALL_ACCESS) as environment_key:  # open registry location
        path_value_list = QueryValueEx(environment_key, 'Path')[0].split(';')            # get and split values in current path value
        try:
            path_value_list.remove(args.pathname)  # removes the pathname from the current path value
        except Exception:
            pass
        finally:
            if args.action == 'APPEND':
                path_value_list.append(args.pathname)  # appends pathname to path
            elif args.action == 'PREPEND':
                path_value_list = [args.pathname] + path_value_list  # prepend pathname to path
        SetValueEx(environment_key, 'Path', 0, REG_SZ, ';'.join(path_value_list))  # write path back to registry