I know this may seem a common question, yes, there are many questions similar to mine and yes, apparently there are solutions but the problem is that I tried them but they do not work.
This is my code:
def testOne():
output = subprocess.run(["htpasswd.exe", "-nb", "spock", "volerevolare"], capture_output=True)
print( output )
print("out: <{o}>".format(o=output.stdout.decode()))
print( "return code: dec {d:d} hex {h:X}".format(d=output.returncode, h=output.returncode) )
#---------------------------------------------------------------------------
and this is its output:
CompletedProcess(args=['htpasswd.exe', '-nb', 'spock', 'volerevolare'], returncode=3221225781, stdout=b'', stderr=b'')
out: <>
return code: dec 3221225781 hex C0000135
so in my opinion after looking at the error code I think that my little applications does not work and htpasswd.exe is not executed.
O.S. is Win 7, normal user (not admin user).
What I missed?
Thanks,
Massimo
OK, problem found, I have also cygwin installed so it was a problem related to PATH. Copying locally the right htpasswd.exe (Windows 10 version) solved the problem. The htpasswd windows version is already installed in Win 10, for previous release I verified it works since Win 7 it is downloadable here: https://www.exefiles.com/it/exe/htpasswd-exe/
I made a MAC address changer for my personal use to convert my MAC address. I want to make this script work on every operating system because the ifconfig command has different syntax depending on which kind of operating system it is being used on. To make this possible, I fit this code in my script:
def mac_change(user_interface, user_mac):
check_uname = subprocess.check_output(['uname'])
print(check_uname)
if str(check_uname) == 'Linux':
subprocess.call(['ifconfig', user_interface, 'down'])
subprocess.call(['ifconfig', user_interface, 'hw', 'ether', user_mac])
subprocess.call(['ifconfig', user_interface, 'up'])
elif str(check_uname) == 'Darwin':
subprocess.call(['ifconfig', user_interface, 'down'])
subprocess.call(['sudo', 'ifconfig', user_interface, 'ether', user_mac])
subprocess.call(['ifconfig', user_interface, 'up'])
else:
print('Incompatible software.')
This is the part of the code where the MAC address of the user-specified device is changed to what the user enters as an option. I intend to add more operating systems later on after I figure out the issue. Anyway, the issue is that when I run it, it seems that two conditionals run instead of only one. These are the results of a test I ran on my MacBook air, which would be Darwin:
MAC changer started!
Changing MAC address to 00:11:22:33:44:55...
Darwin
ifconfig: down: permission denied
Password:
ifconfig: up: permission denied
Incompatible software.
MAC Address successfully changed! New MAC Address: 00:12:13:14:15:19
Why is it printing Incompatible software? It shouldn't. I commented out the whole else part and then it started running the elif along with the if part. I commented out the elif and ran the if and else parts and it started printing out Incompatible software again even though in the end, the MAC address did end up converting. But why is this happening? If anybody needs the full python file to understand and answer my question then I'll provide it. Also, if more information is needed, I'll provide it. Thanks!
I am trying to run the sample of Face API from https://github.com/Microsoft/Cognitive-Face-Python on Ubuntu 12.04 running on the virtual machine (VB). When I select the image to detect, it will send a request and will receive the results but after that:
sample/util.py:176: wxPyDeprecationWarning: Call to deprecated item EmptyImage. Use :class:`Image` instead.
wx_image = wx.EmptyImage(pil_image.width, pil_image.height)
[xcb] Unknown sequence number while processing queue
[xcb] Most likely this is a multi-threaded client and XInitThreads has not been called
[xcb] Aborting, sorry about that.
python: ../../src/xcb_io.c:274: poll_for_event: Assertion `!xcb_xlib_threads_sequence_lost' failed.
Aborted (core dumped)`
I have detected the place where it stops:
try:
attributes = (
'age,gender,headPose,smile,facialHair,glasses,emotion,hair,'
'makeup,occlusion,accessories,blur,exposure,noise'
)
# the call
res = util.CF.face.detect(path, False, False, attributes)
faces = [model.Face(face, path) for face in res]
# ... WON'T GET HERE ...
self.face_list.SetItems(faces)
util.draw_bitmap_rectangle(self.bitmap, faces)
log_text = 'Response: Success. Detected {} face(s) in {}'.format(
len(res), path)
self.log.log(log_text)
text = '{} face(s) has been detected.'.format(len(res))
self.result.SetLabelText(text)
except util.CF.CognitiveFaceException as exp:
self.log.log('Response: {}. {}'.format(exp.code, exp.msg))
This snippet is from the sample/view/panel_detection.py
I failed to reproduce your error with the latest version of code on Windows 10 & macOS 10.12.5 with Python 2.7 and wxPython 3.0.2.0.
The error is not reported directly from the sample code but somewhere inside. And wx.EmptyImage should not be the key point of the error. So I suspect it might has something to do with the environments.
Please ensure you are using the latest version of sample code and corresponding packages. For example, 3.0.2.0 for the wxPython. Ubuntu 12.04 is too old and may suffer on outdated dependencies.
I have to admit that we have limited effort to make it back compatible so please ensure everything is up-to-date. Also feel free to update if there is any further problems.
As told here Qt: Erase background (Windows Aero Glass), I'm using WA_TranslucentBackground to have a glass background on my QMainWindow: on Windows 7 (Aero enabled) it works well, but on Linux (KDE4) I get a black background, I haven't tried on a PC with Aero disabled, or maybe older than Vista.
Is there a way to check if Aero is available and enabled, so I can set WA_TranslucentBackground only if it's enabled, and keep the standard background on Linux and Windows without Aero?
It seems that Windows API's DwmIsCompositionEnabled does the job, but I cannot find how to call it from Python, also taking in account that it may not exist on pre-Vista versions.
You can try something like the following. It should handle being run on non-Windows platforms, and also the absence of the DwmIsCompositionEnabled function:
import ctypes
def is_aero_enabled():
try:
b = ctypes.c_bool()
retcode = ctypes.windll.dwmapi.DwmIsCompositionEnabled(ctypes.byref(b))
return (retcode == 0 and b.value)
except AttributeError:
# No windll, no dwmapi or no DwmIsCompositionEnabled function.
return False
On my Windows 7 machine, this returns True.
Does anyone know how I would go about detected what bit version Windows is under Python. I need to know this as a way of using the right folder for Program Files.
Many thanks
I think the best solution to the problem has been posted by Mark Ribau.
The best answer to the question for Python 2.7 and newer is:
def is_os_64bit():
return platform.machine().endswith('64')
On windows the cross-platform-function platform.machine() internally uses the environmental variables used in Matthew Scoutens answer.
I found the following values:
WinXP-32: x86
Vista-32: x86
Win7-64: AMD64
Debian-32: i686
Debian-64: x86_64
For Python 2.6 and older:
def is_windows_64bit():
if 'PROCESSOR_ARCHITEW6432' in os.environ:
return True
return os.environ['PROCESSOR_ARCHITECTURE'].endswith('64')
To find the Python interpreter bit version I use:
def is_python_64bit():
return (struct.calcsize("P") == 8)
I guess you should look in os.environ['PROGRAMFILES'] for the program files folder.
platform module -- Access to underlying platform’s identifying data
>>> import platform
>>> platform.architecture()
('32bit', 'WindowsPE')
On 64-bit Windows, 32-bit Python returns:
('32bit', 'WindowsPE')
And that means that this answer, even though it has been accepted, is incorrect. Please see some of the answers below for options that may work for different situations.
Came here searching for properly detecting if running on 64bit windows, compiling all the above into something more concise.
Below you will find a function to test if running on 64bit windows, a function to get the 32bit Program Files folder, and a function to get the 64bit Program Files folder; all regardless of running 32bit or 64bit python. When running 32bit python, most things report as if 32bit when running on 64bit, even os.environ['PROGRAMFILES'].
import os
def Is64Windows():
return 'PROGRAMFILES(X86)' in os.environ
def GetProgramFiles32():
if Is64Windows():
return os.environ['PROGRAMFILES(X86)']
else:
return os.environ['PROGRAMFILES']
def GetProgramFiles64():
if Is64Windows():
return os.environ['PROGRAMW6432']
else:
return None
Note: Yes, this is a bit hackish. All other methods that "should just work", do not work when running 32bit Python on 64bit Windows (at least for the various 2.x and 3.x versions I have tried).
Edits:
2011-09-07 - Added a note about why only this hackish method works properly.
def os_platform():
true_platform = os.environ['PROCESSOR_ARCHITECTURE']
try:
true_platform = os.environ["PROCESSOR_ARCHITEW6432"]
except KeyError:
pass
#true_platform not assigned to if this does not exist
return true_platform
http://blogs.msdn.com/b/david.wang/archive/2006/03/26/howto-detect-process-bitness.aspx
Many of these proposed solutions, such as platform.architecture(), fail because their results depend on whether you are running 32-bit or 64-bit Python.
The only reliable method I have found is to check for the existence of os.environ['PROGRAMFILES(X86)'], which is unfortunately hackish.
You should be using environment variables to access this. The program files directory is stored in the environment variable PROGRAMFILES on x86 Windows, the 32-bit program files is directory is stored in the PROGRAMFILES(X86) environment variable, these can be accessed by using os.environ('PROGRAMFILES').
Use sys.getwindowsversion() or the existence of PROGRAMFILES(X86) (if 'PROGRAMFILES(X86)' in os.environ) to determine what version of Windows you are using.
Following this documentation, try this code:
is_64bits = sys.maxsize > 2**32
Im aware that in comments of the question this method was already used.
This is the method the .net framework uses:
import ctypes
def is64_bit_os():
""" Returns wethever system is a 64bit operating system"""
is64bit = ctypes.c_bool()
handle = ctypes.windll.kernel32.GetCurrentProcess() # should be -1, because the current process is currently defined as (HANDLE) -1
success = ctypes.windll.kernel32.IsWow64Process(handle, ctypes.byref(is64bit)) #should return 1
return (success and is64bit).value
print(is64_bit_os())
I just found another way to do this, which may be useful in some situations.
import subprocess
import os
def os_arch():
os_arch = '32-bit'
if os.name == 'nt':
output = subprocess.check_output(['wmic', 'os', 'get', 'OSArchitecture'])
os_arch = output.split()[1]
else:
output = subprocess.check_output(['uname', '-m'])
if 'x86_64' in output:
os_arch = '64-bit'
else:
os_arch = '32-bit'
return os_arch
print 'os_arch=%s' % os_arch()
I tested this code in the following environments:
Ubuntu 16.04 + Python 2.7.12
Mac OS Sierra + Python 2.7.11
Windows 7 Pro 32-bit + Python 2.7.5 (32-bit)
Windows 10 Home 64-bit + Python 2.7.13 (32-bit)
The subject lines asks about detecting 64 or 32bit OS, while the body talks about determining the location of ProgramFiles. The latter has a couple of workable answers here. I'd like to add another solution generalized to handle StartMenu, Desktop, etc. as well as ProgramFiles: How to get path of Start Menu's Programs directory?
When you need to find out things about windows system, it is usually somewhere in the registry, according to MS documentation, you should look at (http://support.microsoft.com/kb/556009) this key value:
HKLM\HARDWARE\DESCRIPTION\System\CentralProcessor\0
and if it is:
0x00000020 (32 in decimal)
It is a 32 bit machine.
64-bit versions of Windows use something called registry redirection and reflection keys. There is a compatibility layer called WoW64 which enables compatibility of 32-bit applications. Starting from Windows 7 and Windows Server 2008 R2 WoW64 registry keys are not longer reflected but shared. You can read about it here:
registry-reflection: msdn.microsoft.com/en-us/library/aa384235(v=vs.85).aspx
affected-keys: msdn.microsoft.com/en-us/library/aa384253(v=vs.85).aspx
wikipedia: en.wikipedia.org/wiki/WoW64
All you need to do is detect existence of those keys. You can use _winreg for that. Use try: and try opening key, example:
try:
aReg = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE,"SOFTWARE\\Wow6432Node\\Microsoft\\Windows\\CurrentVersion\\Run")
import _winreg
def get_registry_value(key, subkey, value):
key = getattr(_winreg, key)
handle = _winreg.OpenKey(key, subkey )
(value, type) = _winreg.QueryValueEx(handle, value)
return value
windowsbit=cputype = get_registry_value(
"HKEY_LOCAL_MACHINE",
"SYSTEM\\CurrentControlSet\Control\\Session Manager\\Environment",
"PROCESSOR_ARCHITECTURE")
print windowsbit
just run this code
if you are working on 64 bit windows machine this will print AMD64
or if you are working on 32 bit it will print AMD32
i hope this code can help to solve this problem fully
This works for me in the Python versions I use: 2.7 and 2.5.4
import win32com.client
import _winreg
shell = win32com.client.Dispatch('WScript.Shell')
proc_arch = shell.ExpandEnvironmentStrings(r'%PROCESSOR_ARCHITECTURE%').lower()
if proc_arch == 'x86':
print "32 bit"
elif proc_arch == 'amd64':
print "64 bit"
else:
raise Exception("Unhandled arch: %s" % proc_arch)
Just to update this old thread - it looks like the platform module reports the correct architecture now (at least, in Python 2.7.8):
c:\python27\python.exe -c "import platform; print platform.architecture(), platform.python_version()"
('32bit', 'WindowsPE') 2.7.6
c:\home\python278-x64\python.exe -c "import platform; print platform.architecture(), platform.python_version()"
('64bit', 'WindowsPE') 2.7.8
(sorry I don't have the rep to comment on the first answer which still claims to be wrong :)
import platform
platform.architecture()[0]
It will return '32bit' or '64bit' depending on system architecture.
The solution posted by Alexander Brüsch is the correct solution, but it has a bug that only reveals itself on python3.x. He neglected to cast the returned value from GetCurrentProcess() to a HANDLE type. Passing a simple integer as the first parameter of IsWow64Process() returns 0 (which is an error flag from win32api). Also, Alexander incorrectly handles the return statement (success has no .value attribute).
For those who stumble on this thread, here is the corrected code:
import ctypes
def is64_bit_os():
"""Returns True if running 32-bit code on 64-bit operating system"""
is64bit = ctypes.c_bool()
handle = ctypes.wintypes.HANDLE(ctypes.windll.kernel32.GetCurrentProcess())
success = ctypes.windll.kernel32.IsWow64Process(handle, ctypes.byref(is64bit))
return success and is64bit.value
print(is64_bit_os())
There is a function named machine in platform module. I installed both Python3.8 32-bit and 64-bit versions on the same 64-bit machine with 64-bit Windows 10 and here is what I found:
And it looks like platform.machine returns machine architecture without bothering what type of python is installed. so here is my
final compilation
import platform
def is_64bit():
return platform.machine().endswith('64')
Most of the answers here are incorrect :/
Here is a simple translation of the well known method used in CMD and this is how microsoft do it too.
import os
_os_bit=64
if os.environ.get('PROCESSOR_ARCHITECTURE').lower() == 'x86' and os.environ.get('PROCESSOR_ARCHITEW6432') is None: _os_bit=32
print(_os_bit)
but remember: Windows 10 on ARM includes an x86-on-ARM64 emulation, so the possible values for PROCESSOR_ARCHITECTURE are: AMD64 or IA64 or ARM64 or x86
A solution, putting together the options from the links below and using os module:
import os
#next save the response from the command prompt saved to a file
window = os.system('PowerShell.exe "gwmi win32_operatingsystem | select osarchitecture" > prompt.txt')
#next read the file
f = open('prompt.txt','r')
windowsos = f.readlines()
f.close()
print(windowsos[3][:-1])
https://datatofish.com/command-prompt-python/
https://www.radishlogic.com/windows/how-to-check-if-your-windows-10-is-64-bit-or-32-bit/
https://www.tutorialspoint.com/how-to-run-a-powershell-script-from-the-command-prompt
import struct
def is64Windows():
return struct.calcsize('P') * 8 == 64
There should be a directory under Windows 64bit, a Folder called \Windows\WinSxS64 for 64 bit, under Windows 32bit, it's WinSxS.