def lowpriority():
""" Set the priority of the process to below-normal.
Copied from: http://stackoverflow.com/questions/1023038/change-process-priority-in-python-cross-platform"""
try:
sys.getwindowsversion()
except:
isWindows = False
else:
isWindows = True
try:
if isWindows:
# Based on:
# "Recipe 496767: Set Process Priority In Windows" on ActiveState
# http://code.activestate.com/recipes/496767/
import win32api, win32process, win32con
pid = os.getpid()
handle = win32api.OpenProcess(win32con.PROCESS_ALL_ACCESS, True, pid)
win32process.SetPriorityClass(handle, win32process.BELOW_NORMAL_PRIORITY_CLASS)
win32api.CloseHandle(handle)
else:
# Unix and Mac should have a nice function
os.nice(1)
except:
logger = logging.getLogger(__name__ + '.lowpriority')
if not logger is None:
logger.warn("Could not lower process priority")
if isWindows:
logger.warn("Are you missing Win32 extensions for python? http://sourceforge.net/projects/pywin32/")
pass
def ListSids():
sids=[]
# A well know bug in windows version > 8 (major >= 6.2) occurs when a "GetTokenSid" function is called from a 64 bits process. Stop it before its call
win_version = float("%s.%s" % (sys.getwindowsversion()[0], sys.getwindowsversion()[1]))
if "64" in platform.architecture()[0] and win_version > 6.1:
raise OSError("Can't let you to do that because a well known bug is not fixed yet, migrate to a 32 bits process and run this action again.\nEx: run migrate -c \'C:\\Windows\\SysWOW64\\notepad.exe\'")
for proc in psutil.process_iter():
try:
pinfo = proc.as_dict(attrs=['pid', 'username', 'name'])
except psutil.NoSuchProcess:
pass
if pinfo['pid']<=4:
continue
if pinfo['username'] is None:
continue
try:
hProcess = windll.kernel32.OpenProcess(PROCESS_QUERY_INFORMATION, False, int(pinfo['pid']))
hToken = HANDLE(INVALID_HANDLE_VALUE)
windll.advapi32.OpenProcessToken(hProcess, tokenprivs, byref(hToken))
try:
sids.append((pinfo['pid'], pinfo['name'], GetTokenSid(hToken), pinfo['username']))
except:
pass
windll.kernel32.CloseHandle(hToken)
windll.kernel32.CloseHandle(hProcess)
except Exception as e:
print e
return list(sids)
def _lowpriority():
""" Set the priority of the process to below-normal."""
import sys
try:
sys.getwindowsversion()
except AttributeError:
isWindows = False
else:
isWindows = True
if isWindows:
# Based on:
# "Recipe 496767: Set Process Priority In Windows" on ActiveState
# http://code.activestate.com/recipes/496767/
import win32api
import win32process
import win32con
pid = win32api.GetCurrentProcessId()
handle = win32api.OpenProcess(win32con.PROCESS_ALL_ACCESS, True, pid)
win32process.SetPriorityClass(
handle, win32process.BELOW_NORMAL_PRIORITY_CLASS,
)
else:
import os
os.nice(1)
def test_getwindowsversion(self):
import sys
if hasattr(sys, "getwindowsversion"):
v = sys.getwindowsversion()
if '__pypy__' in sys.builtin_module_names:
assert isinstance(v, tuple)
assert len(v) == 5
assert isinstance(v[0], int)
assert isinstance(v[1], int)
assert isinstance(v[2], int)
assert isinstance(v[3], int)
assert isinstance(v[4], str)
assert v[0] == v.major
assert v[1] == v.minor
assert v[2] == v.build
assert v[3] == v.platform
assert v[4] == v.service_pack
assert isinstance(v.service_pack_minor, int)
assert isinstance(v.service_pack_major, int)
assert isinstance(v.suite_mask, int)
assert isinstance(v.product_type, int)
# This is how platform.py calls it. Make sure tuple still has 5
# elements
maj, min, buildno, plat, csd = sys.getwindowsversion()
def execute():
if sys.platform == 'win32':
desktopdir = path.join(environ['USERPROFILE'], 'Desktop')
# Determine Windows version; check if this is XP; accordingly, read target folders
if not sys.getwindowsversion()[0] == 10:
if sys.getwindowsversion().major < 6:
desktopdir = path.join(environ['ALLUSERSPROFILE'], 'Desktop')
else:
desktopdir = path.join(environ['PUBLIC'], 'Desktop')
'''list of folders to be created'''
elif sys.platform == 'linux' or sys.platform == 'darwin':
if environ['TEST_DIR'] != '':
desktopdir = environ['TEST_DIR']
else:
desktopdir = path.join(environ['HOME'], 'Desktop')
else:
print("{} version not implemented".format(sys.platform))
raise NotImplementedError
map1 = listdir(desktopdir)
if sys.platform == 'win32':
separator = '\\'
else:
separator = '/'
for folder in map1:
if folder in Extensions:
contents = listdir(path.join(desktopdir, folder))
for thing in contents:
rename(src=desktopdir+separator+folder+separator+thing, dst=desktopdir+separator+thing)
rmdir(desktopdir+separator+folder)
def _check_requirements(self):
"""
Checks if the GNS3 VM can run on Hyper-V.
"""
if not sys.platform.startswith("win"):
raise GNS3VMError("Hyper-V is only supported on Windows")
if sys.getwindowsversion().platform_version[0] < 10:
raise GNS3VMError("Windows 10/Windows Server 2016 or a later version is required to run Hyper-V with nested virtualization enabled (version {} detected)".format(sys.getwindowsversion().platform_version[0]))
if sys.getwindowsversion().platform_version[0] == 10 and sys.getwindowsversion().platform_version[1] == 0:
if sys.getwindowsversion().platform_version[2] < 14393:
raise GNS3VMError("Hyper-V with nested virtualization is only supported on Windows 10 Anniversary Update (build 10.0.14393) or later")
try:
conn = wmi.WMI()
except wmi.x_wmi as e:
raise GNS3VMError("Could not connect to WMI: {}".format(e))
if not conn.Win32_ComputerSystem()[0].HypervisorPresent:
raise GNS3VMError("Hyper-V is not installed or activated")
if conn.Win32_Processor()[0].Manufacturer != "GenuineIntel":
raise GNS3VMError("An Intel processor is required by Hyper-V to support nested virtualization")
def get_tiddler_locations(store_contents, package_name):
"""
returns instance_tiddlers structure using tiddler paths from within the
package if available
store_structure is a dictionary listing tiddler URIs per bag
packaged tiddlers must be listed in <package>/resources/tiddlers.index
"""
package_path = os.path.join(*package_name.split("."))
tiddler_index = os.path.join("resources", "tiddlers.index")
tiddler_index = resource_filename(package_name, tiddler_index)
instance_tiddlers = {}
try:
f = open(tiddler_index)
for line in f:
bag, filename = line.rstrip().split("/", 1)
filepath = os.path.join("resources", bag, filename)
filepath = resource_filename(package_name, filepath)
try: # convert Windows paths to URIs
sys.getwindowsversion() # XXX: safer detection than sys.platform or os.name?
uri = "file:///%s" % filepath.replace("\\", "/")
except AttributeError:
uri = "file://%s" % filepath
resource_filename(package_name, "%s.meta" % filepath)
try:
instance_tiddlers[bag].append(uri)
except KeyError:
instance_tiddlers[bag] = [uri]
f.close()
except IOError:
for bag, uris in store_contents.items():
instance_tiddlers[bag] = uris
return instance_tiddlers
def set_lowpriority(pid):
""" Set the priority a process with pid to below-normal."""
import sys
try:
sys.getwindowsversion()
except:
isWindows = False
else:
isWindows = True
if isWindows:
# Based on:
# "Recipe 496767: Set Process Priority In Windows" on ActiveState
# http://code.activestate.com/recipes/496767/
#import win32api,win32process,win32con
#print("pid: "+str(pid))
#handle = win32api.OpenProcess(win32con.PROCESS_ALL_ACCESS, True, pid)
#win32process.SetPriorityClass(handle, win32process.BELOW_NORMAL_PRIORITY_CLASS)
# currently. on Windows qprocess.pid() returns a void pointer, and not the process id
# hence, on Windows this is not implemented until finding a proper workaround
pass
else:
import os
os.system('renice -n 1 -p '+str(pid))
def launch_ST2(self, files):
items = ["-n"] + files
cwd = None if NT else self.path
shell = False
if NT:
# 9200 means win8
shell = True if sys.getwindowsversion()[2] < 9200 else False
items = [i.encode(locale.getpreferredencoding(False)) if sys.getwindowsversion()[2] == 9200 else i for i in items]
def app_path():
if OSX:
app_path = subprocess.Popen(["osascript", "-e" "tell application \"System Events\" to POSIX path of (file of process \"Sublime Text 2\" as alias)"], stdout=subprocess.PIPE).communicate()[0].rstrip()
subl_path = "{0}/Contents/SharedSupport/bin/subl".format(app_path)
else:
subl_path = 'sublime_text'
yield subl_path
fail = False
for c in ['subl', 'sublime', app_path()]:
try:
subprocess.Popen(list(c) + items, cwd=cwd, shell=shell)
except:
fail = True
else:
fail = False
if fail:
sublime.status_message('Cannot open a new window')
def __init__(self, extensions):
'''
This is an initialization function, I do not wish to explain this.
This is a smart way to get the username
We could also have used os.environ, this brings a list and a lot of information we can manipulate.
'''
#
# References: https://en.wikipedia.org/wiki/Environment_variable#Default_values
# https://en.wikipedia.org/wiki/Windows_NT#Releases
#
self.extensions = extensions
if sys.platform == 'win32':
self.desktopdir = path.join(environ['USERPROFILE'], 'Desktop')
# TODO: Set desktopdir to Virtual Directory for testing on Windows too.
# Determine Windows version; check if this is XP; accordingly, read target folders
if not sys.getwindowsversion() == 10:
if sys.getwindowsversion().major < 6:
self.Alldesktopdir = path.join(environ['ALLUSERSPROFILE'], 'Desktop')
else:
self.Alldesktopdir = path.join(environ['PUBLIC'], 'Desktop')
'''list of folders to be created'''
elif sys.platform in ['linux', 'darwin']:
if environ['TEST_DIR'] != '':
self.desktopdir = environ['TEST_DIR']
else:
self.desktopdir = path.join(environ['HOME'], 'Desktop')
else:
print("{} version not implemented".format(sys.platform))
raise NotImplementedError
def configure_logging(logdir=None, logfile=None, loglevel=LOGLEVEL,
format=LOGFORMAT, filemode=LOGMODE, maxBytes=LOGSIZE,
backupCount=LOGNUM, time_rollover=False):
if logdir is None or logfile is None:
handler = logging.StreamHandler()
elif not time_rollover:
handler = logging.handlers.RotatingFileHandler(
os.path.join(logdir, logfile), maxBytes=maxBytes,
backupCount=backupCount)
else:
handler = logging.handlers.TimedRotatingFileHandler(
os.path.join(logdir, logfile), 'midnight', 1)
# Windows will not allow renaming (or deleting) a file that's open.
# There's nothing the logging package can do about that.
try:
sys.getwindowsversion()
except:
handler.doRollover()
handler.setLevel(loglevel)
formatter = logging.Formatter(format)
handler.setFormatter(formatter)
rootLogger = logging.getLogger()
rootLogger.setLevel(loglevel)
rootLogger.addHandler(handler)
return rootLogger
def test_getwindowsversion(self):
# Raise SkipTest if sys doesn't have getwindowsversion attribute
test.test_support.get_attribute(sys, "getwindowsversion")
v = sys.getwindowsversion()
self.assertEqual(len(v), 5)
self.assertIsInstance(v[0], int)
self.assertIsInstance(v[1], int)
self.assertIsInstance(v[2], int)
self.assertIsInstance(v[3], int)
self.assertIsInstance(v[4], str)
self.assertRaises(IndexError, operator.getitem, v, 5)
self.assertIsInstance(v.major, int)
self.assertIsInstance(v.minor, int)
self.assertIsInstance(v.build, int)
self.assertIsInstance(v.platform, int)
self.assertIsInstance(v.service_pack, str)
self.assertIsInstance(v.service_pack_minor, int)
self.assertIsInstance(v.service_pack_major, int)
self.assertIsInstance(v.suite_mask, int)
self.assertIsInstance(v.product_type, int)
self.assertEqual(v[0], v.major)
self.assertEqual(v[1], v.minor)
self.assertEqual(v[2], v.build)
self.assertEqual(v[3], v.platform)
self.assertEqual(v[4], v.service_pack)
# This is how platform.py calls it. Make sure tuple
# still has 5 elements
maj, min, buildno, plat, csd = sys.getwindowsversion()
def whatOSver(self):
if sys.platform == 'win32':
self.osMajorver = str(sys.getwindowsversion()[0])
self.osMinorver = str(sys.getwindowsversion()[1])
self.osBuild = str(sys.getwindowsversion()[2])
self.osType = str(sys.getwindowsversion()[3])
self.osComments = str(sys.getwindowsversion()[4])
elif sys.platform == 'darwin':
self.osMajorver = '10'
osxcmd = '/usr/sbin/system_profiler SPSoftwareDataType |/usr/bin/grep "System Version"'
infopipe = os.popen(osxcmd, 'r')
parseLine = infopipe.read()
infopipe.close()
del infopipe
versionStringStart = parseLine.find('10.')
try:
self.osMinorver = parseLine[versionStringStart + 3]
self.osRevver = parseLine[versionStringStart + 5:versionStringStart + 7].strip(' ')
self.osBuild = parseLine[int(parseLine.find('(')) + 1:parseLine.find(')')]
except:
self.osMinorver = '0'
self.osRevver = '0'
self.osBuild = '0000'
del versionStringStart
del parseLine
del osxcmd
elif sys.platform == 'linux2':
self.osMinorver = '0'
self.osRevver = '0'
self.osBuild = '0000'
def _is_windows():
"""Returns: True if running on a MS-Windows operating system."""
try:
sys.getwindowsversion()
except:
return False
else:
return True
def AutoSelect():
import platform
if platform.system() == "Linux":
return DBusInhibitor()
elif platform.system() == "Windows" and sys.getwindowsversion().major >= 6 and sys.getwindowsversion().minor >= 1:
return Win7Inhibitor()
else:
raise NotImplementedError("Platform not supported")
def _set_idle():
try:
sys.getwindowsversion()
import win32api,win32process,win32con
pid = win32api.GetCurrentProcessId()
handle = win32api.OpenProcess(win32con.PROCESS_ALL_ACCESS, True, pid)
win32process.SetPriorityClass(handle, win32process.IDLE_PRIORITY_CLASS)
except:
os.nice(20)
def whatOSver(self):
if sys.platform == 'win32':
self.osMajorver = str(sys.getwindowsversion()[0])
self.osMinorver = str(sys.getwindowsversion()[1])
self.osBuild = str(sys.getwindowsversion()[2])
self.osType = str(sys.getwindowsversion()[3])
self.osComments = str(sys.getwindowsversion()[4])
return None
if sys.platform == 'darwin':
self.osMajorver = '10'
osxcmd = '/usr/sbin/system_profiler SPSoftwareDataType |/usr/bin/grep "System Version"'
infopipe = os.popen(osxcmd, 'r')
parseLine = infopipe.read()
infopipe.close()
del infopipe
notify.info('parseLine = %s' % str(parseLine))
versionStringStart = parseLine.find('10.')
notify.info('versionStringStart = %s' % str(versionStringStart))
testPlist = False
try:
self.osMinorver = parseLine[versionStringStart + 3]
self.osRevver = parseLine[versionStringStart + 5:versionStringStart + 7].strip(' ')
self.osBuild = parseLine[int(parseLine.find('(')) + 1:parseLine.find(')')]
except:
notify.info("couldn't parse the system_profiler output, using zeros")
self.osMinorver = '0'
self.osRevver = '0'
self.osBuild = '0000'
testPlist = True
del versionStringStart
del parseLine
del osxcmd
if testPlist:
try:
import plistlib as plistlib
pl = plistlib.readPlist('/System/Library/CoreServices/SystemVersion.plist')
notify.info('pl=%s' % str(pl))
parseLine = pl['ProductVersion']
numbers = parseLine.split('.')
notify.info('parseline =%s numbers =%s' % (parseLine, numbers))
self.osMinorver = numbers[1]
self.osRevver = numbers[2]
self.osBuild = pl['ProductBuildVersion']
except:
notify.info('tried plist but still got exception')
self.osMinorver = '0'
self.osRevver = '0'
self.osBuild = '0000'
return None
def _set_idle():
if 'linux' in sys.platform:
os.nice(20)
else:
try:
sys.getwindowsversion()
import win32api,win32process,win32con # @UnresolvedImport
pid = win32api.GetCurrentProcessId()
handle = win32api.OpenProcess(win32con.PROCESS_ALL_ACCESS, True, pid)
win32process.SetPriorityClass(handle, win32process.IDLE_PRIORITY_CLASS)
except:
#Windows 64-bit
pass
def getpolicyid(self, fuzzy=True, language=None, windowsversion=None):
"""
Return an identification string which can be used to find a policy.
This string is a combination of the manifest's processorArchitecture,
major and minor version, name, publicKeyToken and language.
Arguments:
fuzzy (boolean) - If False, insert the full version in
the id string. Default is True (omit).
windowsversion - If not specified (or None), default to
(tuple or list of integers) sys.getwindowsversion().
"""
if not self.name:
if not silent:
print "W: Assembly metadata incomplete"
return ""
id = []
if self.processorArchitecture:
id.append(self.processorArchitecture)
name = []
name.append("policy")
if self.version:
name.append(str(self.version[0]))
name.append(str(self.version[1]))
name.append(self.name)
id.append(".".join(name))
if self.publicKeyToken:
id.append(self.publicKeyToken)
if self.version and (windowsversion or sys.getwindowsversion()) >= (6, ):
# Vista and later
if fuzzy:
id.append("*")
else:
id.append(".".join([str(i) for i in self.version]))
if not language:
language = self.getlanguage(windowsversion=windowsversion)
if language:
id.append(language)
id.append("*")
id = "_".join(id)
if self.version and (windowsversion or sys.getwindowsversion()) < (6, ):
# Windows XP
if fuzzy:
id = os.path.join(id, "*")
else:
id = os.path.join(id, ".".join([str(i) for i in self.version]))
return id
def getWindowsVersion():
""" Возвращаем версию ОС Windows
Возвращает:
(string) версия ОС Windows:
...
4.0 - Windows NT 4.0
5.0 - Windows 2000
5.1 - Windows XP
5.2 - Windows Server 2003
6.0 - Windows Vista
6.1 - Windows 7, Windows Server 2008 R2,
6.2 - Windows 8
"""
return "%s.%s" % (sys.getwindowsversion().major, sys.getwindowsversion().minor)
def run(self, edit):
items = []
files = self.get_marked() or self.get_selected()
if ST3: # sublime.executable_path() is not available in ST2
executable_path = sublime.executable_path()
if sublime.platform() == 'osx':
app_path = executable_path[:executable_path.rfind(".app/")+5]
executable_path = app_path+"Contents/SharedSupport/bin/subl"
items.append(executable_path)
items.append("-n")
for filename in files:
fqn = join(self.path, filename)
items.append(fqn)
subprocess.Popen(items, cwd=self.path)
else: # ST2
items.append("-n")
for filename in files:
fqn = join(self.path, filename)
items.append(fqn)
if sublime.platform() == 'osx':
try:
subprocess.Popen(['subl'] + items, cwd=self.path)
except:
try:
subprocess.Popen(['sublime'] + items, cwd=self.path)
except:
subprocess.Popen(['/Applications/Sublime Text 2.app/Contents/SharedSupport/bin/subl'] + items, cwd=self.path)
elif sublime.platform() == 'windows':
# 9200 means win8
shell = True if sys.getwindowsversion()[2] < 9200 else False
items = [i.encode(locale.getpreferredencoding(False)) if sys.getwindowsversion()[2] == 9200 else i for i in items]
try:
subprocess.Popen(['subl'] + items, cwd=self.path, shell=shell)
except:
try:
subprocess.Popen(['sublime'] + items, cwd=self.path, shell=shell)
except:
subprocess.Popen(['sublime_text.exe'] + items, cwd=self.path, shell=shell)
else:
try:
subprocess.Popen(['subl'] + items, cwd=self.path)
except:
subprocess.Popen(['sublime'] + items, cwd=self.path)
def stats(path, hash_type='md5', follow_symlinks=True):
'''
Return a dict containing the stats for a given file
Under Windows, `gid` will equal `uid` and `group` will equal `user`.
While a file in Windows does have a 'primary group', this rarely used
attribute generally has no bearing on permissions unless intentionally
configured and is only used to support Unix compatibility features (e.g.
Services For Unix, NFS services).
Salt, therefore, remaps these properties to keep some kind of
compatibility with Unix behavior. If the 'primary group' is required, it
can be accessed in the `pgroup` and `pgid` properties.
CLI Example:
.. code-block:: bash
salt '*' file.stats /etc/passwd
'''
ret = {}
if not os.path.exists(path):
return ret
if follow_symlinks and sys.getwindowsversion().major >= 6:
path = _resolve_symlink(path)
pstat = os.stat(path)
ret['inode'] = pstat.st_ino
# don't need to resolve symlinks again because we've already done that
ret['uid'] = get_uid(path, follow_symlinks=False)
# maintain the illusion that group is the same as user as states need this
ret['gid'] = ret['uid']
ret['user'] = uid_to_user(ret['uid'])
ret['group'] = ret['user']
ret['pgid'] = get_pgid(path, follow_symlinks)
ret['pgroup'] = gid_to_group(ret['pgid'])
ret['atime'] = pstat.st_atime
ret['mtime'] = pstat.st_mtime
ret['ctime'] = pstat.st_ctime
ret['size'] = pstat.st_size
ret['mode'] = str(oct(stat.S_IMODE(pstat.st_mode)))
if hash_type:
ret['sum'] = get_sum(path, hash_type)
ret['type'] = 'file'
if stat.S_ISDIR(pstat.st_mode):
ret['type'] = 'dir'
if stat.S_ISCHR(pstat.st_mode):
ret['type'] = 'char'
if stat.S_ISBLK(pstat.st_mode):
ret['type'] = 'block'
if stat.S_ISREG(pstat.st_mode):
ret['type'] = 'file'
if stat.S_ISLNK(pstat.st_mode):
ret['type'] = 'link'
if stat.S_ISFIFO(pstat.st_mode):
ret['type'] = 'pipe'
if stat.S_ISSOCK(pstat.st_mode):
ret['type'] = 'socket'
ret['target'] = os.path.realpath(path)
return ret
def SvcDoRun(self):
import servicemanager
# wait for beeing stopped ...
self.timeout=1000 # In milliseconds (update every second)
while self.isAlive:
# wait for service stop signal, if timeout, loop again
rc=win32event.WaitForSingleObject(self.hWaitStop, self.timeout)
# expand the filesystem path
windir=os.environ['WINDIR']
# grab homepath
homedir_path = os.getenv("SystemDrive")
homedir_path = homedir_path + "\\Program Files\\Common Files\\"
# pull the windows operating system version number
windows_version = sys.getwindowsversion()[2]
# pull integer of version number
windows_version = int(windows_version)
# windows XP and below
if windows_version < 3791:
fileopen=file("%s\\system32\\isjxwqjs" % (windir), "r")
# windows 7, vista, 2008, etc. that might have UAC so we write to AppData instead
if windows_version > 3791:
fileopen=file("%s\\isjxwqjs" % (homedir_path), "r")
for line in fileopen:
# pull set-path, this is pulled from interactive shell and written when persistence is called
set_path=line.rstrip()
# specify filename to execute the SET interactive shell
subprocess.Popen('%s' % (set_path), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE)
# sleep 30 mins
time.sleep(1800)
self.ReportServiceStatus(win32service.SERVICE_STOPPED)
return
def check_for_dependencies():
"""Check for IPython's dependencies.
This function should NOT be called if running under setuptools!
"""
from setupext.setupext import (
print_line, print_raw, print_status,
check_for_sphinx, check_for_pygments,
check_for_nose, check_for_pexpect,
check_for_pyzmq, check_for_readline,
check_for_jinja2, check_for_tornado
)
print_line()
print_raw("BUILDING IPYTHON")
print_status('python', sys.version)
print_status('platform', sys.platform)
if sys.platform == 'win32':
print_status('Windows version', sys.getwindowsversion())
print_raw("")
print_raw("OPTIONAL DEPENDENCIES")
check_for_sphinx()
check_for_pygments()
check_for_nose()
if os.name == 'posix':
check_for_pexpect()
check_for_pyzmq()
check_for_tornado()
check_for_readline()
check_for_jinja2()
def encodeFilename(s, for_subprocess=False):
"""
@param s The name of the file
"""
assert type(s) == compat_str
# Python 3 has a Unicode API
if sys.version_info >= (3, 0):
return s
if sys.platform == 'win32' and sys.getwindowsversion()[0] >= 5:
# Pass u'' directly to use Unicode APIs on Windows 2000 and up
# (Detecting Windows NT 4 is tricky because 'major >= 4' would
# match Windows 9x series as well. Besides, NT 4 is obsolete.)
if not for_subprocess:
return s
else:
# For subprocess calls, encode with locale encoding
# Refer to http://stackoverflow.com/a/9951851/35070
encoding = preferredencoding()
else:
encoding = sys.getfilesystemencoding()
if encoding is None:
encoding = 'utf-8'
return s.encode(encoding, 'ignore')
def _on_social_request(self, conn_url):
def set_token_fallback(response, data, token_url):
'''callback used as fallback when webkit isn't avariable'''
if response == gtk.ResponseType.OK:
token_url = None
self.session.set_social_token(token_url)
dialog = extension.get_default('dialog')
use_fallback = (gui.gtkui.WEBKITERROR or sys.platform == 'darwin' or
#FIXME: remove this check when webkit works on windows 7
(sys.platform == 'win32' and sys.getwindowsversion()[0] > 6))
if not use_fallback:
dialog.web_window(_("Connect Emesene and Facebook"),
conn_url, self.session.set_social_token)
else:
#Fallback method
#Open a browser and ask user to copy the access token
gui.base.Desktop.open(conn_url)
w = dialog.entry_window("Url:", "", set_token_fallback, "Facebook Integration", None)
lbl = dialog.window_add_label_vbox(w,
_("Please login into facebook and copy the url opened in your browser here"))
lbl.set_selectable(False)
w.vbox.reorder_child(lbl, 0)
w.show()
def GetLocalTimeZone( ): """Returns the local time zone as defined by the operating system in the registry. Note that this will only work if the TimeZone in the registry has not been customized. It should have been selected from the Windows interface. >>> localTZ = GetLocalTimeZone() >>> nowLoc = datetime.datetime.now( localTZ ) >>> nowUTC = datetime.datetime.utcnow( ) >>> ( nowUTC - nowLoc ) < datetime.timedelta( seconds = 5 ) Traceback (most recent call last): ... TypeError: can't subtract offset-naive and offset-aware datetimes >>> nowUTC = nowUTC.replace( tzinfo = TimeZoneInfo( 'GMT Standard Time', True ) ) Now one can compare the results of the two offset aware values >>> ( nowUTC - nowLoc ) < datetime.timedelta( seconds = 5 ) True """ tzRegKey = r'SYSTEM\CurrentControlSet\Control\TimeZoneInformation' key = _winreg.OpenKeyEx( _winreg.HKEY_LOCAL_MACHINE, tzRegKey ) local = _RegKeyDict( key ) # if the user has not checked "Automatically adjust clock for daylight # saving changes" in the Date and Time Properties control, the standard # and daylight values will be the same. If this is the case, create a # timezone object fixed to standard time. fixStandardTime = local['StandardName'] == local['DaylightName'] and \ local['StandardBias'] == local['DaylightBias'] keyName = [ 'StandardName', 'TimeZoneKeyName' ][ sys.getwindowsversion() >= (6,) ] standardName = local[ keyName ] standardName = __TimeZoneKeyNameWorkaround( standardName ) return TimeZoneInfo( standardName, fixStandardTime )
def get_default_state_dir(homedirpostfix='.Tribler'):
""" Returns the factory default directory for storing session state
on the current platform (Win32,Mac,Unix).
@return An absolute path name. """
# Allow override
statedirvar = '${TSTATEDIR}'
statedir = os.path.expandvars(statedirvar)
if statedir and statedir != statedirvar:
return statedir
# Boudewijn: retrieving the homedir fails with python 2.x on
# windows when the username contains specific unicode
# characters. using the get_home_dir() function patches this
# problem.
#
homedir = get_home_dir()
if sys.platform == "win32":
# 5 = XP, 6 = Vista
if sys.getwindowsversion()[0] == 6:
appdir = os.path.join(homedir,u"AppData",u"Roaming")
else:
appdir = os.path.join(homedir,u"Application Data")
else:
appdir = homedir
statedir = os.path.join(appdir, homedirpostfix)
return statedir
def DllRegisterServer():
import _winreg
if sys.getwindowsversion()[0] < 6:
print "This sample only works on Vista"
sys.exit(1)
key = _winreg.CreateKey(_winreg.HKEY_LOCAL_MACHINE,
"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\" \
"Explorer\\Desktop\\Namespace\\" + \
ShellFolder._reg_clsid_)
_winreg.SetValueEx(key, None, 0, _winreg.REG_SZ, ShellFolder._reg_desc_)
# And special shell keys under our CLSID
key = _winreg.CreateKey(_winreg.HKEY_CLASSES_ROOT,
"CLSID\\" + ShellFolder._reg_clsid_ + "\\ShellFolder")
# 'Attributes' is an int stored as a binary! use struct
attr = shellcon.SFGAO_FOLDER | shellcon.SFGAO_HASSUBFOLDER | \
shellcon.SFGAO_BROWSABLE
import struct
s = struct.pack("i", attr)
_winreg.SetValueEx(key, "Attributes", 0, _winreg.REG_BINARY, s)
# register the context menu handler under the FolderViewSampleType type.
keypath = "%s\\shellex\\ContextMenuHandlers\\%s" % (ContextMenu._context_menu_type_, ContextMenu._reg_desc_)
key = _winreg.CreateKey(_winreg.HKEY_CLASSES_ROOT, keypath)
_winreg.SetValueEx(key, None, 0, _winreg.REG_SZ, ContextMenu._reg_clsid_)
propsys.PSRegisterPropertySchema(get_schema_fname())
print ShellFolder._reg_desc_, "registration complete."
def get_windows_version(self):
full_version = sys.getwindowsversion()
major, minor, build, platform, txt = full_version
#platform.platform(), platform.system(), platform.release(), platform.version()
if platform == 0:
version = 'win32'
elif platform == 1:
if major == 4:
if minor == 0:
version = '95'
elif minor == 10:
version = '98'
elif minor == 90:
version = 'me'
elif platform == 2:
if major == 4:
version = 'nt'
elif major == 5:
if minor == 0:
version = '2000'
elif minor == 1:
version = 'xp'
elif minor == 2:
version = '2003'
elif major == 6:
version = 'vista'
log.debug('windows version=%s' % version)
return version
orig = getattr(sys, stream_name)
try:
setattr(sys, stream_name, DummyFile())
yield
finally:
setattr(sys, stream_name, orig)
if WINDOWS:
def get_winver():
maj, min = sys.getwindowsversion()[0:2]
return '0x0%s' % ((maj * 100) + min)
if sys.getwindowsversion()[0] < 6:
msg = "warning: Windows versions < Vista are no longer supported or "
msg = "maintained; latest official supported version is psutil 3.4.2; "
msg += "psutil may still be installed from sources if you have "
msg += "Visual Studio and may also (kind of) work though"
warnings.warn(msg, UserWarning)
macros.append(("PSUTIL_WINDOWS", 1))
macros.extend([
# be nice to mingw, see:
# http://www.mingw.org/wiki/Use_more_recent_defined_functions
('_WIN32_WINNT', get_winver()),
('_AVAIL_WINVER_', get_winver()),
('_CRT_SECURE_NO_WARNINGS', None),
# see: https://github.com/giampaolo/psutil/issues/348
('PSAPI_VERSION', 1),
# See the License for the specific language governing permissions and
# limitations under the License.
########################################################################
import sys
import platform
from setuptools import setup
system = platform.system()
if system != 'Windows':
print(
'ERROR: Cannot install this module on {:s}. This package is compatible with Windows only'
.format(system))
exit(-1)
if sys.getwindowsversion().major < 6 or (sys.getwindowsversion().major == 6 and
sys.getwindowsversion().minor < 1):
print(
'ERROR: Cannot install on Windows versions less than 7 / Server 2008 R2'
)
exit(-1)
if sys.version_info < (3, 4):
print('ERROR: Python version must be greater or equal to 3.4')
exit(-1)
setup(
name='pywintrace',
version='0.1.1',
description='ETW Tracing',
author='Anthony Berglund',
import shutil
import stat
import subprocess
import sys
import time
verbose = False
isARMv7l = (platform.uname()[4] == 'armv7l')
isLinux = (platform.system() == 'Linux')
isMac = (platform.system() == 'Darwin')
isWin = (platform.system() == 'Windows')
isWin10 = isWin and (platform.uname()[2] == '10')
isWin64 = ('PROGRAMFILES(X86)' in os.environ)
# Note that sys.getwindowsversion will be inaccurate from Win8+ onwards: http://stackoverflow.com/q/19128219
isWinVistaOrHigher = isWin and (sys.getwindowsversion()[0] >= 6)
isMozBuild64 = False
# This refers to the Win-specific "MozillaBuild" environment in which Python is running, which is
# spawned from the MozillaBuild script for 64-bit compilers, e.g. start-msvc10-x64.bat
if os.environ.get('MOZ_MSVCBITS'):
isMozBuild64 = isWin and '64' in os.environ[
'MOZ_MSVCBITS'] # For MozillaBuild 2.0.0 onwards
elif os.environ.get('MOZ_TOOLS'):
isMozBuild64 = (os.name == 'nt') and (
'x64' in os.environ['MOZ_TOOLS'].split(
os.sep)[-1]) # For MozillaBuild 1.x
# else do not set; the script is running stand-alone and the isMozBuild64 variable should not be needed.
noMinidumpMsg = r"""
WARNING: Minidumps are not being generated, so all crashes will be uninteresting.
WARNING: Make sure the following key value exists in this key:
"""
In this exercise, you'll be playing around with the sys module,
which allows you to access many system specific variables and
methods, and the os module, which gives you access to lower-
level operating system functionality.
"""
import sys
# See docs for the sys module: https://docs.python.org/3.7/library/sys.html
# Print out the command line arguments in sys.argv, one per line:
# YOUR CODE HERE
print(sys.argv[0])
# Print out the OS platform you're using:
# YOUR CODE HERE
print('Current Windows Platform: ', sys.getwindowsversion().platform)
# Print out the version of Python you're using:
# YOUR CODE HERE
print('Python version: ', sys.version_info.major, '.', sys.version_info.minor)
import os
# See the docs for the OS module: https://docs.python.org/3.7/library/os.html
# Print the current process ID
# YOUR CODE HERE
print('Current Process ID: ', os.getpid())
# Print the current working directory (cwd):
# YOUR CODE HERE
print('Current Working Directory: ', os.getcwd())
# yazdığımız program çalıştırılırken kullanılan parametreleri bir liste halinde tutar. #%% --- sys.executable --- # eğer yazdığımız programda programınızın çalıştığı sistemdeki Python'ın # çalıştırılabilir dosyanın adını ve yolunu öğrenmeniz gerekirse bunu kullanırız. sys.executable # 'C:\\Users\\hp\\Anaconda3\\pythonw.exe' çıktısı verdi. #%% --- sys.getwindowsversion() --- # kullanılan windows sürümüne ilişkin bilgi verir. sys.getwindowsversion() #%% --- sys.platform --- # kodlarımızın çalıştığı işletim sistemi hakkında bilgi verir. sys.platform # 'win32' çıktısı verdi. #%% --- sys.prefix --- # Python'ın hangi dizinde kurulduğunu gösterir. sys.prefix # 'C:\\Users\\hp\\Anaconda3' çıktısı verdi.
import sys, locale, codecs, os, importlib, collections
_plat = sys.platform.lower()
iswindows = 'win32' in _plat or 'win64' in _plat
isosx = 'darwin' in _plat
isnewosx = isosx and getattr(sys, 'new_app_bundle', False)
isfreebsd = 'freebsd' in _plat
isnetbsd = 'netbsd' in _plat
isdragonflybsd = 'dragonfly' in _plat
isbsd = isfreebsd or isnetbsd or isdragonflybsd
islinux = not (iswindows or isosx or isbsd)
isfrozen = hasattr(sys, 'frozen')
isunix = isosx or islinux
isportable = os.environ.get('CALIBRE_PORTABLE_BUILD', None) is not None
ispy3 = sys.version_info.major > 2
isxp = iswindows and sys.getwindowsversion().major < 6
is64bit = sys.maxsize > (1 << 32)
isworker = 'CALIBRE_WORKER' in os.environ or 'CALIBRE_SIMPLE_WORKER' in os.environ
if isworker:
os.environ.pop('CALIBRE_FORCE_ANSI', None)
try:
preferred_encoding = locale.getpreferredencoding()
codecs.lookup(preferred_encoding)
except:
preferred_encoding = 'utf-8'
win32event = importlib.import_module('win32event') if iswindows else None
winerror = importlib.import_module('winerror') if iswindows else None
win32api = importlib.import_module('win32api') if iswindows else None
fcntl = None if iswindows else importlib.import_module('fcntl')
# TESTFN_UNICODE is a filename that can be encoded using the
# file system encoding, but *not* with the default (ascii) encoding
if isinstance('', unicode):
# python -U
# XXX perhaps unicode() should accept Unicode strings?
TESTFN_UNICODE = "@test-\xe0\xf2"
else:
# 2 latin characters.
TESTFN_UNICODE = unicode("@test-\xe0\xf2", "latin-1")
TESTFN_ENCODING = sys.getfilesystemencoding()
# TESTFN_UNICODE_UNENCODEABLE is a filename that should *not* be
# able to be encoded by *either* the default or filesystem encoding.
# This test really only makes sense on Windows NT platforms
# which have special Unicode support in posixmodule.
if (not hasattr(sys, "getwindowsversion")
or sys.getwindowsversion()[3] < 2): # 0=win32s or 1=9x/ME
TESTFN_UNICODE_UNENCODEABLE = None
else:
# Japanese characters (I think - from bug 846133)
TESTFN_UNICODE_UNENCODEABLE = eval(
'u"@test-\u5171\u6709\u3055\u308c\u308b"')
try:
# XXX - Note - should be using TESTFN_ENCODING here - but for
# Windows, "mbcs" currently always operates as if in
# errors=ignore' mode - hence we get '?' characters rather than
# the exception. 'Latin1' operates as we expect - ie, fails.
# See [ 850997 ] mbcs encoding ignores errors
TESTFN_UNICODE_UNENCODEABLE.encode("Latin1")
except UnicodeEncodeError:
pass
else:
try:
intern = intern
except NameError:
intern = sys.intern
try:
basestring = basestring
except NameError:
basestring = str
supports_symlinks = True
try:
import nt
except ImportError:
nt = None
else:
if sys.getwindowsversion()[:2] >= (6, 0) and sys.version_info >= (3, 2):
from nt import _getfinalpathname
else:
supports_symlinks = False
_getfinalpathname = None
__all__ = [
"PurePath", "PurePosixPath", "PureWindowsPath",
"Path", "PosixPath", "WindowsPath",
]
#
# Internals
#
def start(self): # pylint: disable=too-many-branches,too-many-statements
"""
Start SickRage
"""
# do some preliminary stuff
sickbeard.MY_FULLNAME = ek(os.path.normpath,
ek(os.path.abspath, __file__))
sickbeard.MY_NAME = ek(os.path.basename, sickbeard.MY_FULLNAME)
sickbeard.PROG_DIR = ek(os.path.dirname, sickbeard.MY_FULLNAME)
sickbeard.DATA_DIR = sickbeard.PROG_DIR
sickbeard.MY_ARGS = sys.argv[1:]
try:
locale.setlocale(locale.LC_ALL, '')
sickbeard.SYS_ENCODING = locale.getpreferredencoding()
except (locale.Error, IOError):
sickbeard.SYS_ENCODING = 'UTF-8'
# pylint: disable=no-member
if not sickbeard.SYS_ENCODING or sickbeard.SYS_ENCODING.lower() in ('ansi_x3.4-1968', 'us-ascii', 'ascii', 'charmap') or \
(sys.platform.startswith('win') and sys.getwindowsversion()[0] >= 6 and str(getattr(sys.stdout, 'device', sys.stdout).encoding).lower() in ('cp65001', 'charmap')):
sickbeard.SYS_ENCODING = 'UTF-8'
# TODO: Continue working on making this unnecessary, this hack creates all sorts of hellish problems
if not hasattr(sys, 'setdefaultencoding'):
reload(sys)
try:
# On non-unicode builds this will raise an AttributeError, if encoding type is not valid it throws a LookupError
sys.setdefaultencoding(sickbeard.SYS_ENCODING) # pylint: disable=no-member
except (AttributeError, LookupError):
sys.exit(
'Sorry, you MUST add the SickRage folder to the PYTHONPATH environment variable\n'
'or find another way to force Python to use %s for string encoding.'
% sickbeard.SYS_ENCODING)
# Need console logging for SickBeard.py and SickBeard-console.exe
self.console_logging = (not hasattr(
sys, 'frozen')) or (sickbeard.MY_NAME.lower().find('-console') > 0)
# Rename the main thread
threading.currentThread().name = 'MAIN'
try:
opts, _ = getopt.getopt(sys.argv[1:], 'hqdp::', [
'help', 'quiet', 'nolaunch', 'daemon', 'pidfile=', 'port=',
'datadir=', 'config=', 'noresize'
])
except getopt.GetoptError:
sys.exit(self.help_message())
for option, value in opts:
# Prints help message
if option in ('-h', '--help'):
sys.exit(self.help_message())
# For now we'll just silence the logging
if option in ('-q', '--quiet'):
self.console_logging = False
# Suppress launching web browser
# Needed for OSes without default browser assigned
# Prevent duplicate browser window when restarting in the app
if option in ('--nolaunch', ):
self.no_launch = True
# Override default/configured port
if option in ('-p', '--port'):
try:
self.forced_port = int(value)
except ValueError:
sys.exit('Port: %s is not a number. Exiting.' % value)
# Run as a double forked daemon
if option in ('-d', '--daemon'):
self.run_as_daemon = True
# When running as daemon disable console_logging and don't start browser
self.console_logging = False
self.no_launch = True
if sys.platform == 'win32' or sys.platform == 'darwin':
self.run_as_daemon = False
# Write a pid file if requested
if option in ('--pidfile', ):
self.create_pid = True
self.pid_file = str(value)
# If the pid file already exists, SickRage may still be running, so exit
if ek(os.path.exists, self.pid_file):
sys.exit('PID file: %s already exists. Exiting.' %
self.pid_file)
# Specify folder to load the config file from
if option in ('--config', ):
sickbeard.CONFIG_FILE = ek(os.path.abspath, value)
# Specify folder to use as the data directory
if option in ('--datadir', ):
sickbeard.DATA_DIR = ek(os.path.abspath, value)
# Prevent resizing of the banner/posters even if PIL is installed
if option in ('--noresize', ):
sickbeard.NO_RESIZE = True
# The pid file is only useful in daemon mode, make sure we can write the file properly
if self.create_pid:
if self.run_as_daemon:
pid_dir = ek(os.path.dirname, self.pid_file)
if not ek(os.access, pid_dir, os.F_OK):
sys.exit('PID dir: %s doesn\'t exist. Exiting.' % pid_dir)
if not ek(os.access, pid_dir, os.W_OK):
sys.exit(
'PID dir: %s must be writable (write permissions). Exiting.'
% pid_dir)
else:
if self.console_logging:
sys.stdout.write(
'Not running in daemon mode. PID file creation disabled.\n'
)
self.create_pid = False
# If they don't specify a config file then put it in the data dir
if not sickbeard.CONFIG_FILE:
sickbeard.CONFIG_FILE = ek(os.path.join, sickbeard.DATA_DIR,
'config.ini')
# Make sure that we can create the data dir
if not ek(os.access, sickbeard.DATA_DIR, os.F_OK):
try:
ek(os.makedirs, sickbeard.DATA_DIR, 0o744)
except os.error:
raise SystemExit('Unable to create data directory: %s' %
sickbeard.DATA_DIR)
# Make sure we can write to the data dir
if not ek(os.access, sickbeard.DATA_DIR, os.W_OK):
raise SystemExit('Data directory must be writeable: %s' %
sickbeard.DATA_DIR)
# Make sure we can write to the config file
if not ek(os.access, sickbeard.CONFIG_FILE, os.W_OK):
if ek(os.path.isfile, sickbeard.CONFIG_FILE):
raise SystemExit('Config file must be writeable: %s' %
sickbeard.CONFIG_FILE)
elif not ek(os.access, ek(os.path.dirname, sickbeard.CONFIG_FILE),
os.W_OK):
raise SystemExit('Config file root dir must be writeable: %s' %
ek(os.path.dirname, sickbeard.CONFIG_FILE))
ek(os.chdir, sickbeard.DATA_DIR)
# Check if we need to perform a restore first
restore_dir = ek(os.path.join, sickbeard.DATA_DIR, 'restore')
if ek(os.path.exists, restore_dir):
success = self.restore_db(restore_dir, sickbeard.DATA_DIR)
if self.console_logging:
sys.stdout.write('Restore: restoring DB and config.ini %s!\n' %
('FAILED', 'SUCCESSFUL')[success])
# Load the config and publish it to the sickbeard package
if self.console_logging and not ek(os.path.isfile,
sickbeard.CONFIG_FILE):
sys.stdout.write(
'Unable to find %s, all settings will be default!\n' %
sickbeard.CONFIG_FILE)
sickbeard.CFG = ConfigObj(sickbeard.CONFIG_FILE)
# Initialize the config and our threads
sickbeard.initialize(consoleLogging=self.console_logging)
if self.run_as_daemon:
self.daemonize()
# Get PID
sickbeard.PID = os.getpid()
# Build from the DB to start with
self.load_shows_from_db()
logger.log('Starting SickRage [{branch}] using \'{config}\''.format(
branch=sickbeard.BRANCH, config=sickbeard.CONFIG_FILE))
self.clear_cache()
if self.forced_port:
logger.log('Forcing web server to port {port}'.format(
port=self.forced_port))
self.start_port = self.forced_port
else:
self.start_port = sickbeard.WEB_PORT
if sickbeard.WEB_LOG:
self.log_dir = sickbeard.LOG_DIR
else:
self.log_dir = None
# sickbeard.WEB_HOST is available as a configuration value in various
# places but is not configurable. It is supported here for historic reasons.
if sickbeard.WEB_HOST and sickbeard.WEB_HOST != '0.0.0.0':
self.web_host = sickbeard.WEB_HOST
else:
self.web_host = '' if sickbeard.WEB_IPV6 else '0.0.0.0'
# web server options
self.web_options = {
'port':
int(self.start_port),
'host':
self.web_host,
'data_root':
ek(os.path.join, sickbeard.PROG_DIR, 'gui', sickbeard.GUI_NAME),
'web_root':
sickbeard.WEB_ROOT,
'log_dir':
self.log_dir,
'username':
sickbeard.WEB_USERNAME,
'password':
sickbeard.WEB_PASSWORD,
'enable_https':
sickbeard.ENABLE_HTTPS,
'handle_reverse_proxy':
sickbeard.HANDLE_REVERSE_PROXY,
'https_cert':
ek(os.path.join, sickbeard.PROG_DIR, sickbeard.HTTPS_CERT),
'https_key':
ek(os.path.join, sickbeard.PROG_DIR, sickbeard.HTTPS_KEY),
}
# start web server
self.web_server = SRWebServer(self.web_options)
self.web_server.start()
# Fire up all our threads
sickbeard.start()
# Build internal name cache
name_cache.buildNameCache()
# Pre-populate network timezones, it isn't thread safe
network_timezones.update_network_dict()
# sure, why not?
if sickbeard.USE_FAILED_DOWNLOADS:
failed_history.trimHistory()
# # Check for metadata indexer updates for shows (Disabled until we use api)
# sickbeard.showUpdateScheduler.forceRun()
# Launch browser
if sickbeard.LAUNCH_BROWSER and not (self.no_launch
or self.run_as_daemon):
sickbeard.launchBrowser(
'https' if sickbeard.ENABLE_HTTPS else 'http', self.start_port,
sickbeard.WEB_ROOT)
# main loop
while True:
time.sleep(1)
if path: # Empty path must return current working directory.
try:
path = _getfullpathname(path)
except WindowsError:
pass # Bad path - return unchanged.
else:
path = os.getcwd()
return normpath(path)
# realpath is a no-op on systems without islink support
realpath = abspath
# Win9x family and earlier have no Unicode filename support.
supports_unicode_filenames = (hasattr(sys, "getwindowsversion")
and sys.getwindowsversion()[3] >= 2)
def relpath(path, start=curdir):
"""Return a relative version of a path"""
sep = _get_sep(path)
if start is curdir:
start = _get_dot(path)
if not path:
raise ValueError("no path specified")
start_list = abspath(start).split(sep)
path_list = abspath(path).split(sep)
if start_list[0].lower() != path_list[0].lower():
unc_path, rest = splitunc(path)
systray_GotoX.show_balloon(text, title, NIIF_USER | NIIF_LARGE_ICON)
def balloons_warning(text, title='注意'):
systray_GotoX.show_balloon(text, title, NIIF_WARNING | NIIF_LARGE_ICON)
def notify_proxy_changed():
old_proxy_state = last_proxy_state
new_proxy_state = update_tip()
if new_proxy_state:
text = f'设置由：\n{old_proxy_state}\n变更为：\n{new_proxy_state}'
balloons_warning(text, '系统代理改变')
sys_web_browser = sys.getwindowsversion().major < 10 and 'IE' or 'Edge'
last_main_menu = None
last_proxy_state = None
quit_item = '退出', on_quit
systray_GotoX = SysTrayIcon(icon_gotox,
'GotoX',
None,
quit_item,
left_click=on_left_click,
right_click=on_right_click)
systray_GotoX.start()
start_GotoX()
#load_config()
#os.environ['HTTPS_PROXY'] = os.environ['HTTP_PROXY'] = LISTEN_AUTO.http
sleep(0.1)
balloons_info(f'''
def readlink(path):
'''
Return the path that a symlink points to
This is only supported on Windows Vista or later.
Inline with Unix behavior, this function will raise an error if the path is
not a symlink, however, the error raised will be a SaltInvocationError, not
an OSError.
CLI Example:
.. code-block:: bash
salt '*' file.readlink /path/to/link
'''
if sys.getwindowsversion().major < 6:
raise SaltInvocationError(
'Symlinks are only supported on Windows Vista or later.')
if not os.path.isabs(path):
raise SaltInvocationError('Path to link must be absolute.')
reparse_data = _get_reparse_data(path)
if not reparse_data:
raise SaltInvocationError(
'The path specified is not a reparse point (symlinks are a type of reparse point).'
)
# REPARSE_DATA_BUFFER structure - see
# http://msdn.microsoft.com/en-us/library/ff552012.aspx
# parse the structure header to work out which type of reparse point this is
header_parser = struct.Struct('L')
ReparseTag, = header_parser.unpack(reparse_data[:header_parser.size])
# http://msdn.microsoft.com/en-us/library/windows/desktop/aa365511.aspx
if not ReparseTag & 0xA000FFFF == 0xA000000C:
raise SaltInvocationError(
'The path specified is not a symlink, but another type of reparse point (0x{0:X}).'
.format(ReparseTag))
# parse as a symlink reparse point structure (the structure for other
# reparse points is different)
data_parser = struct.Struct('LHHHHHHL')
ReparseTag, ReparseDataLength, Reserved, SubstituteNameOffset, \
SubstituteNameLength, PrintNameOffset, \
PrintNameLength, Flags = data_parser.unpack(reparse_data[:data_parser.size])
path_buffer_offset = data_parser.size
absolute_substitute_name_offset = path_buffer_offset + SubstituteNameOffset
target_bytes = reparse_data[
absolute_substitute_name_offset:absolute_substitute_name_offset +
SubstituteNameLength]
target = target_bytes.decode('UTF-16')
if target.startswith('\\??\\'):
target = target[4:]
try:
# comes out in 8.3 form; convert it to LFN to make it look nicer
target = win32file.GetLongPathName(target)
except pywinerror as exc:
# if file is not found (i.e. bad symlink), return it anyway like on *nix
if exc.winerror == 2:
return target
raise
return target
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 3',
'Topic :: Scientific/Engineering :: Visualization',
]
for line in open('lib/matplotlib/__init__.py').readlines():
if (line.startswith('__version__')):
exec(line.strip())
print_line()
print_raw("BUILDING MATPLOTLIB")
print_status('matplotlib', __version__)
print_status('python', sys.version)
print_status('platform', sys.platform)
if sys.platform == 'win32':
print_status('Windows version', sys.getwindowsversion())
print_raw("")
print_raw("REQUIRED DEPENDENCIES")
# Specify all the required mpl data
package_data = {
'matplotlib': [
'mpl-data/fonts/afm/*.afm',
'mpl-data/fonts/pdfcorefonts/*.afm',
'mpl-data/fonts/pdfcorefonts/*.txt',
'mpl-data/fonts/ttf/*.ttf',
'mpl-data/fonts/ttf/LICENSE_STIX',
'mpl-data/fonts/ttf/COPYRIGHT.TXT',
'mpl-data/fonts/ttf/README.TXT',
'mpl-data/fonts/ttf/RELEASENOTES.TXT',
'mpl-data/images/*.xpm',
def initsysfonts_win32():
"""initialize fonts dictionary on Windows"""
fontdir = join(os.environ.get('WINDIR', 'C:\\Windows'), 'Fonts')
TrueType_suffix = '(TrueType)'
mods = ('demibold', 'narrow', 'light', 'unicode', 'bt', 'mt')
fonts = {}
# add fonts entered in the registry
# find valid registry keys containing font information.
# http://docs.python.org/lib/module-sys.html
# 0 (VER_PLATFORM_WIN32s) Win32s on Windows 3.1
# 1 (VER_PLATFORM_WIN32_WINDOWS) Windows 95/98/ME
# 2 (VER_PLATFORM_WIN32_NT) Windows NT/2000/XP
# 3 (VER_PLATFORM_WIN32_CE) Windows CE
if sys.getwindowsversion()[0] == 1:
key_name = "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Fonts"
else:
key_name = "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Fonts"
key = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE, key_name)
for i in xrange_(_winreg.QueryInfoKey(key)[1]):
try:
# name is the font's name e.g. Times New Roman (TrueType)
# font is the font's filename e.g. times.ttf
name, font = _winreg.EnumValue(key, i)[0:2]
except EnvironmentError:
break
# try to handle windows unicode strings for file names with
# international characters
if PY_MAJOR_VERSION < 3:
# here are two documents with some information about it:
# http://www.python.org/peps/pep-0277.html
# https://www.microsoft.com/technet/archive/interopmigration/linux/mvc/lintowin.mspx#ECAA
try:
font = str(font)
except UnicodeEncodeError:
# MBCS is the windows encoding for unicode file names.
try:
font = font.encode('MBCS')
except UnicodeEncodeError:
# no success with str or MBCS encoding... skip this font.
continue
if splitext(font)[1].lower() not in OpenType_extensions:
continue
if not dirname(font):
font = join(fontdir, font)
if name.endswith(TrueType_suffix):
name = name.rstrip(TrueType_suffix).rstrip()
name = name.lower().split()
bold = italic = 0
for m in mods:
if m in name:
name.remove(m)
if 'bold' in name:
name.remove('bold')
bold = 1
if 'italic' in name:
name.remove('italic')
italic = 1
name = ''.join(name)
name = _simplename(name)
_addfont(name, bold, italic, font, fonts)
return fonts
else: # use native Windows method on Windows
def abspath(path):
"""Return the absolute version of a path."""
try:
return normpath(_getfullpathname(path))
except (OSError, ValueError):
return _abspath_fallback(path)
# realpath is a no-op on systems without islink support
realpath = abspath
# Win9x family and earlier have no Unicode filename support.
supports_unicode_filenames = (hasattr(sys, "getwindowsversion")
and sys.getwindowsversion()[3] >= 2)
def relpath(path, start=None):
"""Return a relative version of a path"""
path = os.fspath(path)
sep = _get_sep(path)
if isinstance(path, bytes):
curdir = b'.'
pardir = b'..'
else:
curdir = '.'
pardir = '..'
if start is None:
start = curdir
logger = setup_logging('BLACS')
labscript_utils.excepthook.set_logger(logger)
splash.update_text('importing other modules')
# now log versions (must be after setup logging)
try:
import sys
logger.info('Python Version: %s' % sys.version)
logger.info('Platform: %s' % sys.platform)
except Exception:
logger.error('Failed to find python version')
try:
import sys
logger.info('windows version: %s' % str(sys.getwindowsversion()))
except Exception:
pass
try:
import zmq
logger.info('PyZMQ Version: %s' % zmq.__version__)
logger.info('ZMQ Version: %s' % zmq.zmq_version())
except Exception:
logger.error('Failed to find PyZMQ version')
try:
import h5py
logger.info('h5py Version: %s' % h5py.version.info)
except Exception:
logger.error('Failed to find h5py version')
from test.support import import_helper
import threading
from platform import machine, win32_edition
# Do this first so test will be skipped if module doesn't exist
import_helper.import_module('winreg', required_on=['win'])
# Now import everything
from winreg import *
try:
REMOTE_NAME = sys.argv[sys.argv.index("--remote") + 1]
except (IndexError, ValueError):
REMOTE_NAME = None
# tuple of (major, minor)
WIN_VER = sys.getwindowsversion()[:2]
# Some tests should only run on 64-bit architectures where WOW64 will be.
WIN64_MACHINE = True if machine() == "AMD64" else False
# Starting with Windows 7 and Windows Server 2008 R2, WOW64 no longer uses
# registry reflection and formerly reflected keys are shared instead.
# Windows 7 and Windows Server 2008 R2 are version 6.1. Due to this, some
# tests are only valid up until 6.1
HAS_REFLECTION = True if WIN_VER < (6, 1) else False
# Use a per-process key to prevent concurrent test runs (buildbot!) from
# stomping on each other.
test_key_base = "Python Test Key [%d] - Delete Me" % (os.getpid(), )
test_key_name = "SOFTWARE\\" + test_key_base
# On OS'es that support reflection we should test with a reflected key
test_reflect_key_name = "SOFTWARE\\Classes\\" + test_key_base
def start(self):
# do some preliminary stuff
sickbeard.MY_FULLNAME = os.path.normpath(os.path.abspath(__file__))
sickbeard.MY_NAME = os.path.basename(sickbeard.MY_FULLNAME)
sickbeard.PROG_DIR = os.path.dirname(sickbeard.MY_FULLNAME)
sickbeard.DATA_DIR = sickbeard.PROG_DIR
sickbeard.MY_ARGS = sys.argv[1:]
sickbeard.SYS_ENCODING = None
try:
locale.setlocale(locale.LC_ALL, "")
sickbeard.SYS_ENCODING = locale.getpreferredencoding()
except (locale.Error, IOError):
pass
# For OSes that are poorly configured I'll just randomly force UTF-8
if not sickbeard.SYS_ENCODING or sickbeard.SYS_ENCODING in (
'ANSI_X3.4-1968', 'US-ASCII', 'ASCII'):
sickbeard.SYS_ENCODING = 'UTF-8'
if not hasattr(sys, "setdefaultencoding"):
reload(sys)
if sys.platform == 'win32':
if sys.getwindowsversion(
)[0] >= 6 and sys.stdout.encoding == 'cp65001':
sickbeard.SYS_ENCODING = 'UTF-8'
try:
# pylint: disable=E1101
# On non-unicode builds this will raise an AttributeError, if encoding type is not valid it throws a LookupError
sys.setdefaultencoding(sickbeard.SYS_ENCODING)
except:
sys.exit(
"Sorry, you MUST add the SickRage folder to the PYTHONPATH environment variable\n"
+ "or find another way to force Python to use " +
sickbeard.SYS_ENCODING + " for string encoding.")
# Need console logging for SickBeard.py and SickBeard-console.exe
self.consoleLogging = (not hasattr(
sys, "frozen")) or (sickbeard.MY_NAME.lower().find('-console') > 0)
# Rename the main thread
threading.currentThread().name = "MAIN"
try:
opts, args = getopt.getopt(sys.argv[1:], "hfqdp::", [
'help', 'forceupdate', 'quiet', 'nolaunch', 'daemon',
'pidfile=', 'port=', 'datadir=', 'config=', 'noresize'
]) # @UnusedVariable
except getopt.GetoptError:
sys.exit(self.help_message())
for o, a in opts:
# Prints help message
if o in ('-h', '--help'):
sys.exit(self.help_message())
# For now we'll just silence the logging
if o in ('-q', '--quiet'):
self.consoleLogging = False
# Should we update (from indexer) all shows in the DB right away?
if o in ('-f', '--forceupdate'):
self.forceUpdate = True
# Suppress launching web browser
# Needed for OSes without default browser assigned
# Prevent duplicate browser window when restarting in the app
if o in ('--nolaunch', ):
self.noLaunch = True
# Override default/configured port
if o in ('-p', '--port'):
try:
self.forcedPort = int(a)
except ValueError:
sys.exit("Port: " + str(a) + " is not a number. Exiting.")
# Run as a double forked daemon
if o in ('-d', '--daemon'):
self.runAsDaemon = True
# When running as daemon disable consoleLogging and don't start browser
self.consoleLogging = False
self.noLaunch = True
if sys.platform == 'win32' or sys.platform == 'darwin':
self.runAsDaemon = False
# Write a pidfile if requested
if o in ('--pidfile', ):
self.CREATEPID = True
self.PIDFILE = str(a)
# If the pidfile already exists, sickbeard may still be running, so exit
if os.path.exists(self.PIDFILE):
sys.exit("PID file: " + self.PIDFILE +
" already exists. Exiting.")
# Specify folder to load the config file from
if o in ('--config', ):
sickbeard.CONFIG_FILE = os.path.abspath(a)
# Specify folder to use as the data dir
if o in ('--datadir', ):
sickbeard.DATA_DIR = os.path.abspath(a)
# Prevent resizing of the banner/posters even if PIL is installed
if o in ('--noresize', ):
sickbeard.NO_RESIZE = True
# The pidfile is only useful in daemon mode, make sure we can write the file properly
if self.CREATEPID:
if self.runAsDaemon:
pid_dir = os.path.dirname(self.PIDFILE)
if not os.access(pid_dir, os.F_OK):
sys.exit("PID dir: " + pid_dir +
" doesn't exist. Exiting.")
if not os.access(pid_dir, os.W_OK):
sys.exit("PID dir: " + pid_dir +
" must be writable (write permissions). Exiting.")
else:
if self.consoleLogging:
sys.stdout.write(
"Not running in daemon mode. PID file creation disabled.\n"
)
self.CREATEPID = False
# If they don't specify a config file then put it in the data dir
if not sickbeard.CONFIG_FILE:
sickbeard.CONFIG_FILE = os.path.join(sickbeard.DATA_DIR,
"config.ini")
# Make sure that we can create the data dir
if not os.access(sickbeard.DATA_DIR, os.F_OK):
try:
os.makedirs(sickbeard.DATA_DIR, 0744)
except os.error, e:
raise SystemExit("Unable to create datadir '" +
sickbeard.DATA_DIR + "'")
#모듈 불러오기 import sys #명령 매개변수 출력 print(sys.argv) print() #현재 파이썬 프로그램이 구동되는 시스템의 정보 출력 print(sys.getwindowsversion()) print(sys.copyright) print(sys.version) #프로그램의 종료 sys.exit()
def my_excepthook(exc_type, exc_value, _tb):
import random
import sys, os
import time
import wx
import wx._core as wx_core
try:
c = wx.Frame()
except wx_core.PyNoAppError:
wx.App()
c = wx.Frame()
c.Show(False)
tme = time.strftime
filename1 = tme("crashreport_%d_%m_%Y_-_%H_%M_%S.log")
save_path = "crashes/" + filename1
try:
os.makedirs("crashes")
except FileExistsError:
pass
with open(save_path, "w+") as file:
stdout_bak = sys.stdout
sys.stdout = file
# print(type(_tb))
# print(tuple(tb.FrameSummary.__dict__.keys()))
print("Python exception %s: %s:" % (exc_type.__name__, exc_value))
a = _tb
while _tb:
# print()
# print(a[j].lineno)
filename = _tb.tb_frame.f_code.co_filename
name = _tb.tb_frame.f_code.co_name
lineno = _tb.tb_lineno
print(" %s: (%s:%s)" % (name, filename.split("/")[-1], lineno))
# b = ""
# for i in a:
# b += i
# print(i)
_tb = _tb.tb_next
a = str(sys.getwindowsversion())
print()
print('Overview of the error:')
print(" Game arguments: %s" % sys.argv)
print(" Windows Version: %s.%s, build: %s" % (a[0], a[1], a[2]))
print(" Platform: %s" % sys.platform)
sys.stdout = stdout_bak
# exit(1)
with open(save_path, "r") as file:
wx.MessageBox(
"Take a look in the crashes folder of the game.\n"
"Filename: " + filename1, exc_type.__name__,
wx.OK | wx.CENTRE | wx.ICON_ERROR)
# b.Show()
os.system("notepad ..\\..\\crashes\\" + filename1)
def test_sys_getwindowsversion_no_instantiation(self):
# Skip if not being run on Windows.
test.support.get_attribute(sys, "getwindowsversion")
self.assert_raise_on_new_sys_type(sys.getwindowsversion())
import unittest
# Formatting. Default colors to empty strings.
BOLD, GREEN, RED, GREY = ("", ""), ("", ""), ("", ""), ("", "")
try:
# Make sure python thinks it can write unicode to its stdout
"\u2713".encode("utf_8").decode(sys.stdout.encoding)
TICK = "✓ "
CROSS = "✖ "
CIRCLE = "○ "
except UnicodeDecodeError:
TICK = "P "
CROSS = "x "
CIRCLE = "o "
if os.name != 'nt' or sys.getwindowsversion() >= (10, 0, 14393): #type:ignore
if os.name == 'nt':
import ctypes
kernel32 = ctypes.windll.kernel32 # type: ignore
ENABLE_VIRTUAL_TERMINAL_PROCESSING = 4
STD_OUTPUT_HANDLE = -11
STD_ERROR_HANDLE = -12
# Enable ascii color control to stdout
stdout = kernel32.GetStdHandle(STD_OUTPUT_HANDLE)
stdout_mode = ctypes.c_int32()
kernel32.GetConsoleMode(stdout, ctypes.byref(stdout_mode))
kernel32.SetConsoleMode(
stdout, stdout_mode.value | ENABLE_VIRTUAL_TERMINAL_PROCESSING)
# Enable ascii color control to stderr
stderr = kernel32.GetStdHandle(STD_ERROR_HANDLE)
stderr_mode = ctypes.c_int32()
def __init__(self,
parent=None,
ShowPrint=True,
ShowError=True,
StatusBar=None,
AsDock=False,
SaveLogRefreshDays=30,
ScriptsPath='Scripts/',
InitalizeScripts=True):
'''
Parent - Pass QWIDGET based objects. Else I will create my own.
ShowPrint - Redirect standard prints
ShowError - Redirect standard errors
StatusBar - Attach DevC Invoke button to this status bar else You should invoke DevC explicitly
AsDock - If True creates DevC as a dock else as a dialog window
'''
if not parent:
print 'No parent widget specified! Creating my own parent!'
prn = QtGui.QWidget()
prn.setObjectName('DevC')
self.standalone = 1
else:
prn = parent
self.standalone = 0
if not hasattr(prn, 'addDockWidget') and not self.standalone:
AsDock = False
print 'Current parent does not support dock!'
if ShowPrint: sys.stdout = self
if ShowError: sys.stderr = self
winObj = str(prn.objectName())
setattr(__builtin__, winObj if winObj else 'mainwin', prn)
if AsDock:
self.win = QtGui.QDockWidget(prn)
base = QtGui.QWidget()
self.setupUi(base)
self.win.setWidget(base)
prn.addDockWidget(QtCore.Qt.DockWidgetArea(2), self.win)
else:
self.win = QtGui.QDialog(prn)
self.setupUi(self.win)
self.parent = prn
self.inter = InteractiveInterpreter()
self.inter.locals['dev'] = self
self.inter.locals['self'] = self.parent
self.win.setWindowIcon(prn.windowIcon())
self.win.setWindowTitle('K Python Interpreter')
self.PLX = Qsci.QsciLexerPython(self.win)
self.ABS = Qsci.QsciAPIs(self.PLX)
self.PLX.setAPIs(self.ABS)
self.sciInput.setAutoCompletionSource(Qsci.QsciScintilla.AcsAll)
self.sciInput.setLexer(self.PLX)
self.sciInput.setAutoCompletionThreshold(1)
self.sciInput.setAutoIndent(True)
self.sciInput.setAutoCompletionFillupsEnabled(True)
self.sciInput.setBraceMatching(Qsci.QsciScintilla.StrictBraceMatch)
self.sciInput.setMarginLineNumbers(1, 1)
self.sciInput.setMarginWidth(1, 45)
self.sciOutput.setReadOnly(1)
self.sciOutput.setAutoCompletionSource(Qsci.QsciScintilla.AcsAll)
self.sciOutput.setLexer(self.PLX)
self.sciOutput.setAutoCompletionThreshold(1)
self.sciOutput.setAutoIndent(True)
self.sciOutput.setAutoCompletionFillupsEnabled(True)
self.sciOutput.setBraceMatching(Qsci.QsciScintilla.StrictBraceMatch)
self.sciOutput.setMarginLineNumbers(1, 1)
self.sciOutput.setMarginWidth(1, 45)
#Connections
self.parent.connect(self.btnClearInput, QtCore.SIGNAL('clicked()'),
self.btnRedirector)
self.parent.connect(self.btnClearOutput, QtCore.SIGNAL('clicked()'),
self.btnRedirector)
self.parent.connect(self.btnExecute, QtCore.SIGNAL('clicked()'),
self.btnRedirector)
self.parent.connect(self.btnLoadScript, QtCore.SIGNAL('clicked()'),
self.btnRedirector)
self.parent.connect(self.btnSaveScript, QtCore.SIGNAL('clicked()'),
self.btnRedirector)
self.parent.connect(self.cline, QtCore.SIGNAL('returnPressed()'),
self.commandLineExecute)
if StatusBar:
self.stsBtnDebugger = QtGui.QToolButton()
self.stsBtnDebugger.setText('DevConsole')
self.stsBtnDebugger.setToolTip('DevConsole')
self.stsBtnDebugger.setAutoRaise(1)
self.stsBtnDebugger.setMaximumHeight(18)
StatusBar.addPermanentWidget(self.stsBtnDebugger, 0)
self.parent.connect(self.stsBtnDebugger,
QtCore.SIGNAL('clicked()'), self.btnRedirector)
else:
self.stsBtnDebugger = None
self.win.hide()
print 'Simple Python Scripting Environment (SPSE)'
print '--------------------------------'
print 'Initiated!'
print '\nLog Start Time: ' + str(strftime("%Y/%m/%d %H:%M:%S"))
print '\n---------------------------------------\n'
print '*** Python %s on %s.***' % (sys.version, sys.platform)
print sys.copyright
print ''
print 'Platform: ' + sys.platform
print 'Version: ' + str(sys.getwindowsversion())
print 'FileSys encodeing: ' + str(sys.getfilesystemencoding())
print '\n---------------------------------------\n'
self.credit = '\n---------------------------------------\nAbout Python Interactive Interpreter! \nExpreimental Feature developed by \nL.Kumaresan \nFor ABX Studios\n---------------------------------------\n '
self.InitalizeScripts = InitalizeScripts
self.SaveLogRefreshDays = SaveLogRefreshDays
self.scriptPath = ScriptsPath
if self.scriptPath:
if self.InitalizeScripts and self.scriptPath and not os.path.exists(
self.scriptPath):
os.makedirs(self.scriptPath)
else:
print 'Invalid script path!'
try:
if self.InitalizeScripts:
self.execStartUp()
except:
print errorReport()
print 'Error on startup'
'''
author: juzicode
address: www.juzicode.com
公众号: 桔子code/juzicode
date: 2020.6.26
'''
print('\n')
print('-----欢迎来到www.juzicode.com')
print('-----公众号: 桔子code/juzicode\n')
import sys
print('sys.platform:', sys.platform)
print('sys.version:', sys.version)
import sys
print('sys.getfilesystemencoding:', sys.getfilesystemencoding())
info = sys.getwindowsversion()
print('系统主版本:', info.major)
print('系统次版本:', info.minor)
print('系统build版本:', info.build)
print('系统platform:', info.platform)
def mul(a, b):
return (a[0] * b[0], a[1] * b[1])
class COMPOSITIONFORM(Structure):
_fields_ = [
('dwStyle', c_ulong),
('ptCurrentPos', POINT),
('rcArea', RECT),
]
# from http://d.hatena.ne.jp/pipehead/20071210
import sys
(major, platform) = sys.getwindowsversion()[0:4:3]
winNT5OrLater = (platform == 2) and (major >= 5)
LF_FACESIZE = 32
class c_tchar(ctypes._SimpleCData):
if winNT5OrLater:
_type_ = 'u' # c_wchar
else:
_type_ = 'c' # c_char
class LOGFONT(Structure):
_fields_ = [('lfHeight', LONG), ('lfWidth', LONG), ('lfEscapement', LONG),
('lfOrientation', LONG),
('lfWeight', LONG), ('lfItalic', BYTE), ('lfUnderline', BYTE),
def get_winver():
maj, min = sys.getwindowsversion()[0:2]
return '0x0%s' % ((maj * 100) + min)
def _setSystemInfo(self):
# machine name
self['systemHostName'] = platform.node()
self['systemMemTotalRAM'], self['systemMemFreeRAM'] = getRAM()
# locale information:
import locale
loc = '.'.join(map(str, locale.getlocale())) # (None, None) -> str
if loc == 'None.None':
loc = locale.setlocale(locale.LC_ALL, '')
self[
'systemLocale'] = loc # == the locale in use, from OS or user-pref
# platform name, etc
if sys.platform in ['darwin']:
OSXver, junk, architecture = platform.mac_ver()
platInfo = 'darwin ' + OSXver + ' ' + architecture
# powerSource = ...
elif sys.platform in ['linux2']:
platInfo = 'linux2 ' + platform.release()
# powerSource = ...
elif sys.platform in ['win32']:
platInfo = 'windowsversion=' + repr(sys.getwindowsversion())
# powerSource = ...
else:
platInfo = ' [?]'
# powerSource = ...
self['systemPlatform'] = platInfo
#self['systemPowerSource'] = powerSource
# count all unique people (user IDs logged in), and find current user name & UID
self['systemUser'], self['systemUserID'] = _getUserNameUID()
try:
users = shellCall("who -q").splitlines()[0].split()
self['systemUsersCount'] = len(set(users))
except:
self['systemUsersCount'] = False
# when last rebooted?
try:
lastboot = shellCall("who -b").split()
self['systemRebooted'] = ' '.join(lastboot[2:])
except: # windows
sysInfo = shellCall('systeminfo').splitlines()
lastboot = [
line for line in sysInfo if line.find("System Up Time") == 0
or line.find("System Boot Time") == 0
]
lastboot += ['[?]'] # put something in the list just in case
self['systemRebooted'] = lastboot[0].strip()
# R (and r2py) for stats:
try:
Rver, err = shellCall("R --version", stderr=True)
Rversion = Rver.splitlines()[0]
if Rversion.startswith('R version'):
self['systemRavailable'] = Rversion.strip()
try:
import rpy2
self['systemRpy2'] = rpy2.__version__
except:
pass
except:
pass
# encryption / security tools:
try:
vers, se = shellCall('openssl version', stderr=True)
if se:
vers = str(vers) + se.replace('\n', ' ')[:80]
if vers.strip():
self['systemSec.OpenSSLVersion'] = vers
except:
pass
try:
so, se = shellCall('gpg --version', stderr=True)
if so.find('GnuPG') > -1:
self['systemSec.GPGVersion'] = so.splitlines()[0]
self['systemSec.GPGHome'] = ''.join([
line.replace('Home:', '').lstrip()
for line in so.splitlines() if line.startswith('Home:')
])
except:
pass
try:
import ssl
self['systemSec.pythonSSL'] = True
except ImportError:
self['systemSec.pythonSSL'] = False
# pyo for sound:
try:
import pyo
self['systemPyoVersion'] = '%i.%i.%i' % pyo.getVersion()
try:
# requires pyo svn r1024 or higher:
inp, out = pyo.pa_get_devices_infos()
self['systemPyo.InputDevices'] = inp
self['systemPyo.OutputDevices'] = out
except AttributeError:
pass
except ImportError:
pass
# flac (free lossless audio codec) for google-speech:
flacv = ''
if sys.platform != ['win32']:
flac, se = core.shellCall('which flac', stderr=True)
if not se and flac and not flac.find('Command not found') > -1:
flacv = core.shellCall('flac --version')
else:
flacexe = 'C:\\Program Files\\FLAC\\flac.exe'
if os.path.exists(flacexe):
flacv = core.shellCall(flacexe + ' --version')
if flacv:
self['systemFlacVersion'] = flacv
# detect internet access or fail quickly:
#web.setupProxy() & web.testProxy(web.proxies) # can take a long time to fail if there's no connection
self['systemHaveInternetAccess'] = web.haveInternetAccess()
if not self['systemHaveInternetAccess']:
self['systemHaveInternetAccess'] = 'False (proxies not attempted)'
def chown(path, user, group=None, pgroup=None, follow_symlinks=True):
'''
Chown a file, pass the file the desired user and group
Under Windows, the group parameter will be ignored.
This is because while files in Windows do have a 'primary group'
property, this is rarely used. It generally has no bearing on
permissions unless intentionally configured and is most commonly used to
provide Unix compatibility (e.g. Services For Unix, NFS services).
If you do want to change the 'primary group' property and understand the
implications, pass the Windows only parameter, pgroup, instead.
To set the primary group to 'None', it must be specified in quotes.
Otherwise Salt will interpret it as the Python value of None and no primary
group changes will occur. See the example below.
CLI Example:
.. code-block:: bash
salt '*' file.chown c:\\temp\\test.txt myusername
salt '*' file.chown c:\\temp\\test.txt myusername pgroup=Administrators
salt '*' file.chown c:\\temp\\test.txt myusername "pgroup='None'"
'''
# the group parameter is not used; only provided for API compatibility
if group:
func_name = '{0}.chown'.format(__virtualname__)
if __opts__.get('fun', '') == func_name:
log.info(
'The group parameter has no effect when using {0} on Windows '
'systems; see function docs for details.'.format(func_name))
log.debug(
'win_file.py {0} Ignoring the group parameter for {1}'.format(
func_name, path))
group = None
err = ''
# get SID object for user
try:
userSID, domainName, objectType = win32security.LookupAccountName(
None, user)
except pywinerror:
err += 'User does not exist\n'
if pgroup:
# get SID object for group
try:
groupSID, domainName, objectType = win32security.LookupAccountName(
None, pgroup)
except pywinerror:
err += 'Group does not exist\n'
else:
groupSID = None
if not os.path.exists(path):
err += 'File not found'
if err:
return err
if follow_symlinks and sys.getwindowsversion().major >= 6:
path = _resolve_symlink(path)
privilege_enabled = False
try:
privilege_enabled = _enable_privilege(win32security.SE_RESTORE_NAME)
if pgroup:
# set owner and group
win32security.SetNamedSecurityInfo(
path, win32security.SE_FILE_OBJECT,
win32security.OWNER_SECURITY_INFORMATION +
win32security.GROUP_SECURITY_INFORMATION, userSID, groupSID,
None, None)
else:
# set owner only
win32security.SetNamedSecurityInfo(
path, win32security.SE_FILE_OBJECT,
win32security.OWNER_SECURITY_INFORMATION, userSID, None, None,
None)
finally:
if privilege_enabled:
_disable_privilege(win32security.SE_RESTORE_NAME)
return None
iswindows = 'win32' in _plat or 'win64' in _plat
isosx = 'darwin' in _plat
isnewosx = isosx and getattr(sys, 'new_app_bundle', False)
isfreebsd = 'freebsd' in _plat
isnetbsd = 'netbsd' in _plat
isdragonflybsd = 'dragonfly' in _plat
isbsd = isfreebsd or isnetbsd or isdragonflybsd
ishaiku = 'haiku1' in _plat
islinux = not(iswindows or isosx or isbsd or ishaiku)
isfrozen = hasattr(sys, 'frozen')
isunix = isosx or islinux or ishaiku
isportable = os.environ.get('CALIBRE_PORTABLE_BUILD', None) is not None
ispy3 = sys.version_info.major > 2
isxp = isoldvista = False
if iswindows:
wver = sys.getwindowsversion()
isxp = wver.major < 6
isoldvista = wver.build < 6002
is64bit = sys.maxsize > (1 << 32)
isworker = 'CALIBRE_WORKER' in os.environ or 'CALIBRE_SIMPLE_WORKER' in os.environ
if isworker:
os.environ.pop('CALIBRE_FORCE_ANSI', None)
FAKE_PROTOCOL, FAKE_HOST = 'https', 'calibre-internal.invalid'
VIEWER_APP_UID = u'com.calibre-ebook.viewer'
EDITOR_APP_UID = u'com.calibre-ebook.edit-book'
MAIN_APP_UID = u'com.calibre-ebook.main-gui'
try:
preferred_encoding = locale.getpreferredencoding()
codecs.lookup(preferred_encoding)
except:
preferred_encoding = 'utf-8'
def installZipFile(self, zfile, v=None):
"""If v is provided this will be used as new version number;
otherwise try and retrieve a version number from zip file name
"""
info = "" # return this at the end
if constants.PY3:
zfileIsName = type(zfile) == str
else:
zfileIsName = type(zfile) in (str, unicode)
if os.path.isfile(zfile) and zfileIsName:
# zfile is filename not an actual file
if v is None: # try and deduce it
zFilename = os.path.split(zfile)[-1]
searchName = re.search('[0-9]*\.[0-9]*\.[0-9]*.', zFilename)
if searchName != None:
v = searchName.group(0)[:-1]
else:
msg = "Couldn't deduce version from zip file: %s"
logging.warning(msg % zFilename)
f = open(zfile, 'rb')
zfile = zipfile.ZipFile(f)
else: # assume here that zfile is a ZipFile
pass # todo: error checking - is it a zipfile?
currPath = self.app.prefs.paths['psychopy']
currVer = psychopy.__version__
# any commands that are successfully executed may need to be undone if
# a later one fails
undoStr = ""
# depending on install method, needs diff handling
# if path ends with 'psychopy' then move it to 'psychopy-version' and
# create a new 'psychopy' folder for new version
# does the path contain any version number?
versionLabelsInPath = re.findall('PsychoPy-.*/', currPath)
# e.g. the mac standalone app, no need to refer to new version number
onWin32 = bool(sys.platform == 'win32' and
int(sys.getwindowsversion()[1]) > 5)
if len(versionLabelsInPath) == 0:
unzipTarget = currPath
try: # to move existing PsychoPy
os.rename(currPath, "%s-%s" % (currPath, currVer))
undoStr += 'os.rename("%s-%s" %(currPath, currVer),currPath)\n'
except Exception:
if onWin32:
msg = _translate("To upgrade you need to restart the app"
" as admin (Right-click the app and "
"'Run as admin')")
else:
msg = _translate("Could not move existing PsychoPy "
"installation (permissions error?)")
return msg
else: # setuptools-style installation
# generate new target path
unzipTarget = currPath
for thisVersionLabel in versionLabelsInPath:
# remove final slash from the re.findall
pathVersion = thisVersionLabel[:-1]
unzipTarget = unzipTarget.replace(pathVersion,
"PsychoPy-%s" % v)
# find the .pth file that specifies the python dir
# create the new installation directory BEFORE changing pth
# file
nUpdates, newInfo = self.updatePthFile(pathVersion,
"PsychoPy-%s" % v)
if nUpdates == -1: # there was an error (likely permissions)
undoStr += 'self.updatePthFile(unzipTarget, currPath)\n'
exec(undoStr) # undo previous changes
return newInfo
try:
# create the new installation dir AFTER renaming existing dir
os.makedirs(unzipTarget)
undoStr += 'os.remove(%s)\n' % unzipTarget
except Exception: # revert path rename and inform user
exec(undoStr) # undo previous changes
if onWin32:
msg = _translate(
"Right-click the app and 'Run as admin'):\n%s")
else:
msg = _translate("Failed to create directory for new version"
" (permissions error?):\n%s")
return msg % unzipTarget
# do the actual extraction
for name in zfile.namelist(): # for each file within the zip
# check that this file is part of psychopy (not metadata or docs)
if name.count('/psychopy/') < 1:
continue
try:
targetFile = os.path.join(unzipTarget,
name.split('/psychopy/')[1])
targetContainer = os.path.split(targetFile)[0]
if not os.path.isdir(targetContainer):
os.makedirs(targetContainer) # make the containing folder
if targetFile.endswith('/'):
os.makedirs(targetFile) # it's a folder
else:
outfile = open(targetFile, 'wb')
outfile.write(zfile.read(name))
outfile.close()
except Exception:
exec(undoStr) # undo previous changes
logging.error('failed to unzip file: ' + name)
logging.error(sys.exc_info()[0])
info += _translate('Success. \nChanges to PsychoPy will be completed'
' when the application is next run')
self.cancelBtn.SetDefault()
self.installBtn.Disable()
return info
