def _crash(delay=None):
"""Induces a segfault."""
if delay:
time.sleep(delay)
import faulthandler
faulthandler.disable()
faulthandler._sigsegv()
def test_enable(self):
import faulthandler, sys
faulthandler.enable()
assert faulthandler.is_enabled() is True
faulthandler.enable(file=sys.stderr, all_threads=True)
faulthandler.disable()
assert faulthandler.is_enabled() is False
def qt_message_handler(msg_type, context, msg):
"""Qt message handler to redirect qWarning etc. to the logging system.
Args:
QtMsgType msg_type: The level of the message.
QMessageLogContext context: The source code location of the message.
msg: The message text.
"""
# Mapping from Qt logging levels to the matching logging module levels.
# Note we map critical to ERROR as it's actually "just" an error, and fatal
# to critical.
qt_to_logging = {
QtDebugMsg: logging.DEBUG,
QtWarningMsg: logging.WARNING,
QtCriticalMsg: logging.ERROR,
QtFatalMsg: logging.CRITICAL,
}
# Change levels of some well-known messages to debug so they don't get
# shown to the user.
# suppressed_msgs is a list of regexes matching the message texts to hide.
suppressed_msgs = (
# PNGs in Qt with broken color profile
# https://bugreports.qt-project.org/browse/QTBUG-39788
"libpng warning: iCCP: Not recognizing known sRGB profile that has "
"been edited",
# Hopefully harmless warning
"OpenType support missing for script [0-9]*",
# Error if a QNetworkReply gets two different errors set. Harmless Qt
# bug on some pages.
# https://bugreports.qt-project.org/browse/QTBUG-30298
"QNetworkReplyImplPrivate::error: Internal problem, this method must "
"only be called once."
# Not much information about this, but it seems harmless
'QXcbWindow: Unhandled client message: "_GTK_LOAD_ICONTHEMES"')
if any(re.match(pattern, msg.strip()) for pattern in suppressed_msgs):
level = logging.DEBUG
else:
level = qt_to_logging[msg_type]
if context.function is None:
func = 'none'
else:
# We get something like
# "void qt_png_warning(png_structp, png_const_charp)" from Qt, but only
# want "qt_png_warning".
match = re.match(r'.*( |::)(\w*)\(.*\)', context.function)
if match is not None:
func = match.group(2)
else:
func = context.function
name = 'qt' if context.category == 'default' else 'qt-' + context.category
if msg.splitlines()[0] == ('This application failed to start because it '
'could not find or load the Qt platform plugin '
'"xcb".'):
# Handle this message specially.
msg += ("\n\nOn Archlinux, this should fix the problem:\n"
" pacman -S libxkbcommon-x11")
faulthandler.disable()
record = qt.makeRecord(name, level, context.file, context.line, msg, None,
None, func)
qt.handle(record)
def disable_faulthandler(self):
"""
Cancel the faulthandling, close the file handle and remove the file.
"""
if not PY3:
# Not implemented
return
if self.faulthandler_handle:
faulthandler.disable()
self.faulthandler_handle.close()
self.faulthandler_handle = None
def cleanup():
from mixer.share_data import share_data
try:
if share_data.local_server_process:
share_data.local_server_process.kill()
except Exception:
pass
if _disable_fault_handler:
faulthandler.disable()
def pytest_unconfigure(self, config: Config) -> None:
import faulthandler
faulthandler.disable()
# close our dup file installed during pytest_configure
# re-enable the faulthandler, attaching it to the default sys.stderr
# so we can see crashes after pytest has finished, usually during
# garbage collection during interpreter shutdown
config._store[fault_handler_stderr_key].close()
del config._store[fault_handler_stderr_key]
faulthandler.enable(file=self._get_stderr_fileno())
def pytest_unconfigure(config: Config) -> None:
import faulthandler
faulthandler.disable()
# Close the dup file installed during pytest_configure.
if fault_handler_stderr_key in config._store:
config._store[fault_handler_stderr_key].close()
del config._store[fault_handler_stderr_key]
if config._store.get(fault_handler_originally_enabled_key, False):
# Re-enable the faulthandler if it was originally enabled.
faulthandler.enable(file=get_stderr_fileno())
def test_is_enabled(self):
was_enabled = faulthandler.is_enabled()
try:
faulthandler.enable()
self.assertTrue(faulthandler.is_enabled())
faulthandler.disable()
self.assertFalse(faulthandler.is_enabled())
finally:
if was_enabled:
faulthandler.enable()
else:
faulthandler.disable()
def reset_log_location(cls, new_log_location: str) -> None:
"""Re-acquire file handles to error logs based in the new location.
Class state:
- Overwrites `cls._log_dir`, `cls._pid_specific_error_fileobj`, and
`cls._shared_error_fileobj`.
OS state:
- May create a new directory.
- Overwrites signal handlers for many fatal and non-fatal signals (but not SIGUSR2).
:raises: :class:`ExceptionSink.ExceptionSinkError` if the directory does not exist or is not
writable.
"""
# We could no-op here if the log locations are the same, but there's no reason not to have the
# additional safety of re-acquiring file descriptors each time (and erroring out early if the
# location is no longer writable).
try:
safe_mkdir(new_log_location)
except Exception as e:
raise cls.ExceptionSinkError(
"The provided log location path at '{}' is not writable or could not be created: {}.".format(
new_log_location, str(e)
),
e,
)
pid = os.getpid()
pid_specific_log_path = cls.exceptions_log_path(for_pid=pid, in_dir=new_log_location)
shared_log_path = cls.exceptions_log_path(in_dir=new_log_location)
assert pid_specific_log_path != shared_log_path
try:
pid_specific_error_stream = safe_open(pid_specific_log_path, mode="w")
shared_error_stream = safe_open(shared_log_path, mode="a")
except Exception as e:
raise cls.ExceptionSinkError(
"Error opening fatal error log streams for log location '{}': {}".format(
new_log_location, str(e)
)
)
# NB: mutate process-global state!
if faulthandler.is_enabled():
logger.debug("re-enabling faulthandler")
# Call Py_CLEAR() on the previous error stream:
# https://github.com/vstinner/faulthandler/blob/master/faulthandler.c
faulthandler.disable()
# Send a stacktrace to this file if interrupted by a fatal error.
faulthandler.enable(file=pid_specific_error_stream, all_threads=True)
# NB: mutate the class variables!
cls._log_dir = new_log_location
cls._pid_specific_error_fileobj = pid_specific_error_stream
cls._shared_error_fileobj = shared_error_stream
def pytest_unconfigure(config):
import faulthandler
faulthandler.disable()
# close our dup file installed during pytest_configure
f = getattr(config, "fault_handler_stderr", None)
if f is not None:
# re-enable the faulthandler, attaching it to the default sys.stderr
# so we can see crashes after pytest has finished, usually during
# garbage collection during interpreter shutdown
config.fault_handler_stderr.close()
del config.fault_handler_stderr
faulthandler.enable(file=_get_stderr_fileno())
def cleanup():
from mixer import stats
from mixer.share_data import share_data
if share_data.current_statistics is not None and share_data.auto_save_statistics:
stats.save_statistics(share_data.current_statistics, share_data.statistics_directory)
try:
if share_data.local_server_process:
share_data.local_server_process.kill()
except Exception:
pass
if _disable_fault_handler:
faulthandler.disable()
async def generate_mapping_pairs(filename_uuid: str, source_file: Path, target_file: Path) -> Tuple[str, DataFrame]:
"""
This method makes a separate process to handle the cumbersome mapping process without impacting the current event
loop. Firstly it prepares the folder structure necessary to receive all the intermediate logs and the outcome files
the process generates throughout its execution. Then it forwards the given xsd ``source_file`` to a parsing process
that invokes the jaxb jar in order to generate final java classes to annotate later in the program flow.
At the end of its execution, the method groups received mappings by their source term and sorts those groups by
highest confidence score.
Args:
filename_uuid: unique identifier for user's folder
source_file: the xsd file that defines the java classes
target_file: the ontology file which will handle mapping suggestions
Returns:
tuple: a tuple containing:
- filename_uuid ([str]): hash for the current call
- sorted_group ([DataFrame]): a ``DataFrame`` containing all mapping pairs grouped by their source term and sorted by
highest confidence score
"""
faulthandler.enable()
start_time = time.perf_counter()
df = None
try:
loop = asyncio.get_running_loop()
logger.info('Starting executor for mapping process')
with ProcessPoolExecutor() as pool:
logger.info('Using executor pool')
df = await loop.run_in_executor(pool, start_mapping, source_file, target_file, filename_uuid)
logger.info('Exited executor pool block')
except Exception as e:
logger.warning('Exception during mapping: ' + str(e))
raise API_Exception(ErrorCode.GENERIC, 'Mapping failed')
if df is None:
logger.warning('Mapping process terminated with an error. Please check')
raise API_Exception(ErrorCode.GENERIC, 'Mapping pairs file not created')
faulthandler.disable()
mapping_time = time.perf_counter()
df['confidence_score'] = df['confidence_score'].apply(lambda x: x * 100)
sorted_group = df.sort_values('confidence_score', ascending=False).groupby('source_term', as_index=False)\
[['mapped_term', 'confidence_score']].agg(lambda x: list(x))
end_time = time.perf_counter()
log_entry = f"{filename_uuid}, source [{source_file.name}], target [{target_file.name}], mapping_time [{mapping_time - start_time}], sorting_time [{end_time - mapping_time}], exe_time [{end_time - start_time}]"
performance_logger.info(log_entry)
return filename_uuid, sorted_group
def destroy_crashlogfile(self):
"""Clean up the crash log file and delete it."""
if self._crash_log_file is None:
return
# We use sys.__stderr__ instead of sys.stderr here so this will still
# work when sys.stderr got replaced, e.g. by "Python Tools for Visual
# Studio".
if sys.__stderr__ is not None:
faulthandler.enable(sys.__stderr__)
else:
faulthandler.disable()
try:
self._crash_log_file.close()
os.remove(self._crash_log_file.name)
except OSError:
log.destroy.exception("Could not remove crash log!")
def _destroy_crashlogfile(self):
"""Clean up the crash log file and delete it."""
if self._crashlogfile is None:
return
# We use sys.__stderr__ instead of sys.stderr here so this will still
# work when sys.stderr got replaced, e.g. by "Python Tools for Visual
# Studio".
if sys.__stderr__ is not None:
faulthandler.enable(sys.__stderr__)
else:
faulthandler.disable()
self._crashlogfile.close()
try:
os.remove(self._crashlogfile.name)
except (PermissionError, FileNotFoundError):
log.destroy.exception("Could not remove crash log!")
def exit(self, signum, frame):
self.reload_event.set()
self.reload = False
self._log.info("Zeit zum Begraben gehn...\n PluginManager wird heruntergefahren...")
self.pm.shutdown()
self._log.info("MQTT Thread wird gestoppt...")
self.mqtt_client.loop_stop()
self._log.info("Config wird entladen...")
self.config.save()
self.config.stop()
self._log.info("Beende mich...")
if faulthandler.is_enabled():
faulthandler.disable()
if self.faultFile is not None and not self.faultFile.closed:
self.faultFile.close()
exit(0)
def setUp(self):
if not jpype.isJVMStarted():
try:
import faulthandler
faulthandler.enable()
faulthandler.disable()
except:
pass
root = path.dirname(path.abspath(path.dirname(__file__)))
jpype.addClassPath(path.join(root, 'classes'))
jvm_path = jpype.getDefaultJVMPath()
logger = logging.getLogger(__name__)
logger.info("Running testsuite using JVM %s" % jvm_path)
classpath_arg = "-Djava.class.path=%s"
args = ["-ea", "-Xmx256M", "-Xms16M"]
if self._checkjni:
args.append("-Xcheck:jni")
# TODO: enabling this check crashes the JVM with: FATAL ERROR in native method: Bad global or local ref passed to JNI
# "-Xcheck:jni",
if self._classpath:
from pathlib import Path
import warnings
# This needs to be relative to run location
jpype.addClassPath(Path(self._classpath).resolve())
warnings.warn("using jar instead of thunks")
if self._convertStrings:
import warnings
warnings.warn("using deprecated convertStrings")
if self._jacoco:
import warnings
args.append(
"-javaagent:lib/org.jacoco.agent-0.8.5-runtime.jar=destfile=build/coverage/jacoco.exec,includes=org.jpype.*"
)
warnings.warn("using JaCoCo")
import pathlib
jpype.addClassPath(pathlib.Path("lib/*").absolute())
jpype.addClassPath(pathlib.Path("test/jar/*").absolute())
classpath_arg %= jpype.getClassPath()
args.append(classpath_arg)
_jpype.enableStacktraces(True)
#JPypeTestCase.str_conversion = eval(os.getenv('JPYPE_STR_CONVERSION', 'True'))
jpype.startJVM(jvm_path,
*args,
convertStrings=self._convertStrings)
self.jpype = jpype.JPackage('jpype')
if sys.version < '3':
self.assertCountEqual = self.assertItemsEqual
def enableFaulthandler():
""" Enable faulthandler for all threads.
If the faulthandler package is available, this function disables and then
re-enables fault handling for all threads (this is necessary to ensure any
new threads are handled correctly), and returns True.
If faulthandler is not available, then returns False.
"""
try:
import faulthandler
# necessary to disable first or else new threads may not be handled.
faulthandler.disable()
faulthandler.enable(all_threads=True)
return True
except ImportError:
return False
def ignore_faults() -> None:
'''
Disable Python's standard handler for **segmentation faults** (i.e., memory
access violations by the active Python process, caused by attempting to
access inaccessible, illegal, or otherwise invalid memory locations).
This function reverts to Python's default behavior with respect to
segmentation faults. On the first segmentation fault, Python will abruptly
terminate this process with *no* traceback or advance notice.
See Also
----------
:func:`handle_faults`
Function re-enabling this handler.
'''
faulthandler.disable()
def enableFaulthandler():
""" Enable faulthandler for all threads.
If the faulthandler package is available, this function disables and then
re-enables fault handling for all threads (this is necessary to ensure any
new threads are handled correctly), and returns True.
If faulthandler is not available, then returns False.
"""
try:
import faulthandler
# necessary to disable first or else new threads may not be handled.
faulthandler.disable()
faulthandler.enable(all_threads=True)
return True
except ImportError:
return False
def main() -> int:
"""Start Home Assistant."""
validate_python()
args = get_arguments()
if not args.ignore_os_check:
validate_os()
if args.script is not None:
# pylint: disable=import-outside-toplevel
from . import scripts
return scripts.run(args.script)
config_dir = os.path.abspath(os.path.join(os.getcwd(), args.config))
ensure_config_path(config_dir)
# pylint: disable=import-outside-toplevel
from . import runner
runtime_conf = runner.RuntimeConfig(
config_dir=config_dir,
verbose=args.verbose,
log_rotate_days=args.log_rotate_days,
log_file=args.log_file,
log_no_color=args.log_no_color,
skip_pip=args.skip_pip,
safe_mode=args.safe_mode,
debug=args.debug,
open_ui=args.open_ui,
)
fault_file_name = os.path.join(config_dir, FAULT_LOG_FILENAME)
with open(fault_file_name, mode="a", encoding="utf8") as fault_file:
faulthandler.enable(fault_file)
exit_code = runner.run(runtime_conf)
faulthandler.disable()
if os.path.getsize(fault_file_name) == 0:
os.remove(fault_file_name)
check_threads()
return exit_code
def disable():
"""Disable crash reporting and removes the target file
Does not raise.
"""
global _fileobj
if _fileobj is None:
return
faulthandler.disable()
try:
_fileobj.close()
os.unlink(_fileobj.name)
except (OSError, IOError):
pass
_fileobj = None
def disable():
"""Disable crash reporting and removes the target file
Does not raise.
"""
global _fileobj
if _fileobj is None:
return
faulthandler.disable()
try:
_fileobj.close()
os.unlink(_fileobj.name)
except (OSError, IOError):
pass
_fileobj = None
def pytest_sessionstart(session: pytest.Session):
"""
Hook called after the pytest Session object has been created and
before performing collection and entering the run test loop.
The dask-sql library uses the jpype library which starts a JVM and allows
us to use Java classes from Python. But the JVM will trigger a
segmentation fault when starting and when interrupting threads and Pythons
fault handler can intercept these operations and interpret these as
real faults. So we need to disable faulthandlers which pytest starts
otherwise we get segmentation faults when running the tests.
See (https://jpype.readthedocs.io/en/latest/userguide.html#errors-reported-by-python-fault-handler)
"""
try:
import faulthandler
faulthandler.enable()
faulthandler.disable()
except ImportError:
warnings.warn("Faulthandler lib not available.")
def test_is_enabled(self):
orig_stderr = sys.stderr
try:
# regrtest may replace sys.stderr by io.StringIO object, but
# faulthandler.enable() requires that sys.stderr has a fileno()
# method
sys.stderr = sys.__stderr__
was_enabled = faulthandler.is_enabled()
try:
faulthandler.enable()
self.assertTrue(faulthandler.is_enabled())
faulthandler.disable()
self.assertFalse(faulthandler.is_enabled())
finally:
if was_enabled:
faulthandler.enable()
else:
faulthandler.disable()
finally:
sys.stderr = orig_stderr
def test_is_enabled(self):
orig_stderr = sys.stderr
try:
# regrtest may replace sys.stderr by io.StringIO object, but
# faulthandler.enable() requires that sys.stderr has a fileno()
# method
sys.stderr = sys.__stderr__
was_enabled = faulthandler.is_enabled()
try:
faulthandler.enable()
self.assertTrue(faulthandler.is_enabled())
faulthandler.disable()
self.assertFalse(faulthandler.is_enabled())
finally:
if was_enabled:
faulthandler.enable()
else:
faulthandler.disable()
finally:
sys.stderr = orig_stderr
def reset_log_location(cls, new_log_location):
"""Re-acquire file handles to error logs based in the new location.
Class state:
- Overwrites `cls._log_dir`, `cls._pid_specific_error_fileobj`, and
`cls._shared_error_fileobj`.
OS state:
- May create a new directory.
- Overwrites signal handlers for many fatal and non-fatal signals.
:raises: :class:`ExceptionSink.ExceptionSinkError` if the directory does not exist or is not
writable.
"""
# We could no-op here if the log locations are the same, but there's no reason not to have the
# additional safety of re-acquiring file descriptors each time (and erroring out early if the
# location is no longer writable).
# Create the directory if possible, or raise if not writable.
cls._check_or_create_new_destination(new_log_location)
pid_specific_error_stream, shared_error_stream = cls._recapture_fatal_error_log_streams(
new_log_location)
# NB: mutate process-global state!
if faulthandler.is_enabled():
logger.debug('re-enabling faulthandler')
# Call Py_CLEAR() on the previous error stream:
# https://github.com/vstinner/faulthandler/blob/master/faulthandler.c
faulthandler.disable()
# Send a stacktrace to this file if interrupted by a fatal error.
faulthandler.enable(file=pid_specific_error_stream, all_threads=True)
# Log a timestamped exception and exit gracefully on non-fatal signals.
for signum in cls.all_gracefully_handled_signals:
signal.signal(signum, cls.handle_signal_gracefully)
signal.siginterrupt(signum, False)
# NB: mutate the class variables!
cls._log_dir = new_log_location
cls._pid_specific_error_fileobj = pid_specific_error_stream
cls._shared_error_fileobj = shared_error_stream
def disable():
"""Disable crash reporting and removes the target file
Does not raise.
"""
global _fileobj, _enabled
assert _enabled
_enabled = False
if _fileobj is None:
return
faulthandler.disable()
try:
_fileobj.close()
os.unlink(_fileobj.name)
except IOError:
pass
_fileobj = None
def test_open_excel(self):
import pywintypes
# not using context manager because we call .quit manually
wb1 = open_excel(visible=False)
app1 = wb1.app
# close workbook but leave app instance open (anything using wb1 will fail now)
wb1.close()
# disable faulthandler to avoid annoying "Windows fatal exception" messages in the console
# See https://github.com/pywinauto/pywinauto/issues/858
# and https://stackoverflow.com/questions/57523762/pytest-windows-fatal-exception-code-0x8001010d
faulthandler_enabled = faulthandler.is_enabled()
if faulthandler_enabled:
faulthandler.disable()
with pytest.raises(pywintypes.com_error):
wb1.sheet_names()
if faulthandler_enabled:
faulthandler.enable()
wb2 = open_excel(visible=False)
app2 = wb2.app
assert app1 == app2 == xw_excel.global_app
# this effectively close all workbooks but leaves the instance intact (this is probably due to us keeping a
# reference to it).
app1.quit()
# anything using wb2 will fail
if faulthandler_enabled:
faulthandler.disable()
with pytest.raises(pywintypes.com_error):
wb2.sheet_names()
if faulthandler_enabled:
faulthandler.enable()
# in any case, this should work
with open_excel(visible=False) as wb:
wb['test'] = 'content'
def reset_log_location(cls, new_log_location):
"""Re-acquire file handles to error logs based in the new location.
Class state:
- Overwrites `cls._log_dir`, `cls._pid_specific_error_fileobj`, and
`cls._shared_error_fileobj`.
OS state:
- May create a new directory.
- Overwrites signal handlers for many fatal and non-fatal signals (but not SIGUSR2).
:raises: :class:`ExceptionSink.ExceptionSinkError` if the directory does not exist or is not
writable.
"""
# We could no-op here if the log locations are the same, but there's no reason not to have the
# additional safety of re-acquiring file descriptors each time (and erroring out early if the
# location is no longer writable).
# Create the directory if possible, or raise if not writable.
cls._check_or_create_new_destination(new_log_location)
pid_specific_error_stream, shared_error_stream = cls._recapture_fatal_error_log_streams(
new_log_location)
# NB: mutate process-global state!
if faulthandler.is_enabled():
logger.debug('re-enabling faulthandler')
# Call Py_CLEAR() on the previous error stream:
# https://github.com/vstinner/faulthandler/blob/master/faulthandler.c
faulthandler.disable()
# Send a stacktrace to this file if interrupted by a fatal error.
faulthandler.enable(file=pid_specific_error_stream, all_threads=True)
# NB: mutate the class variables!
cls._log_dir = new_log_location
cls._pid_specific_error_fileobj = pid_specific_error_stream
cls._shared_error_fileobj = shared_error_stream
def qt_message_handler(msg_type, context, msg):
"""Qt message handler to redirect qWarning etc. to the logging system.
Args:
QtMsgType msg_type: The level of the message.
QMessageLogContext context: The source code location of the message.
msg: The message text.
"""
# Mapping from Qt logging levels to the matching logging module levels.
# Note we map critical to ERROR as it's actually "just" an error, and fatal
# to critical.
qt_to_logging = {
QtCore.QtDebugMsg: logging.DEBUG,
QtCore.QtWarningMsg: logging.WARNING,
QtCore.QtCriticalMsg: logging.ERROR,
QtCore.QtFatalMsg: logging.CRITICAL,
}
try:
# pylint: disable=no-member,useless-suppression
qt_to_logging[QtCore.QtInfoMsg] = logging.INFO
except AttributeError:
# Qt < 5.5
pass
# Change levels of some well-known messages to debug so they don't get
# shown to the user.
#
# If a message starts with any text in suppressed_msgs, it's not logged as
# error.
suppressed_msgs = [
# PNGs in Qt with broken color profile
# https://bugreports.qt.io/browse/QTBUG-39788
'libpng warning: iCCP: Not recognizing known sRGB profile that has '
'been edited', # flake8: disable=E131
'libpng warning: iCCP: known incorrect sRGB profile',
# Hopefully harmless warning
'OpenType support missing for script ',
# Error if a QNetworkReply gets two different errors set. Harmless Qt
# bug on some pages.
# https://bugreports.qt.io/browse/QTBUG-30298
'QNetworkReplyImplPrivate::error: Internal problem, this method must '
'only be called once.',
# Sometimes indicates missing text, but most of the time harmless
'load glyph failed ',
# Harmless, see https://bugreports.qt.io/browse/QTBUG-42479
'content-type missing in HTTP POST, defaulting to '
'application/x-www-form-urlencoded. '
'Use QNetworkRequest::setHeader() to fix this problem.',
# https://bugreports.qt.io/browse/QTBUG-43118
'Using blocking call!',
# Hopefully harmless
'"Method "GetAll" with signature "s" on interface '
'"org.freedesktop.DBus.Properties" doesn\'t exist',
'"Method \\"GetAll\\" with signature \\"s\\" on interface '
'\\"org.freedesktop.DBus.Properties\\" doesn\'t exist\\n"',
'WOFF support requires QtWebKit to be built with zlib support.',
# Weird Enlightment/GTK X extensions
'QXcbWindow: Unhandled client message: "_E_',
'QXcbWindow: Unhandled client message: "_ECORE_',
'QXcbWindow: Unhandled client message: "_GTK_',
# Happens on AppVeyor CI
'SetProcessDpiAwareness failed:',
# https://bugreports.qt.io/browse/QTBUG-49174
'QObject::connect: Cannot connect (null)::stateChanged('
'QNetworkSession::State) to '
'QNetworkReplyHttpImpl::_q_networkSessionStateChanged('
'QNetworkSession::State)',
]
if sys.platform == 'darwin':
suppressed_msgs += [
'libpng warning: iCCP: known incorrect sRGB profile',
# https://bugreports.qt.io/browse/QTBUG-47154
'virtual void QSslSocketBackendPrivate::transmit() SSLRead failed '
'with: -9805', # flake8: disable=E131
]
# Messages which will trigger an exception immediately
critical_msgs = [
'Could not parse stylesheet of object',
]
if any(msg.strip().startswith(pattern) for pattern in critical_msgs):
# For some reason, the stack gets lost when raising here...
logger = logging.getLogger('misc')
logger.error("Got critical Qt warning!", stack_info=True)
raise CriticalQtWarning(msg)
elif any(msg.strip().startswith(pattern) for pattern in suppressed_msgs):
level = logging.DEBUG
else:
level = qt_to_logging[msg_type]
if context.function is None:
func = 'none'
elif ':' in context.function:
func = '"{}"'.format(context.function)
else:
func = context.function
if context.category is None or context.category == 'default':
name = 'qt'
else:
name = 'qt-' + context.category
if msg.splitlines()[0] == ('This application failed to start because it '
'could not find or load the Qt platform plugin '
'"xcb".'):
# Handle this message specially.
msg += ("\n\nOn Archlinux, this should fix the problem:\n"
" pacman -S libxkbcommon-x11")
faulthandler.disable()
stack = ''.join(traceback.format_stack())
record = qt.makeRecord(name,
level,
context.file,
context.line,
msg,
None,
None,
func,
sinfo=stack)
qt.handle(record)
def qt_message_handler(msg_type, context, msg):
"""Qt message handler to redirect qWarning etc. to the logging system.
Args:
QtMsgType msg_type: The level of the message.
QMessageLogContext context: The source code location of the message.
msg: The message text.
"""
# Mapping from Qt logging levels to the matching logging module levels.
# Note we map critical to ERROR as it's actually "just" an error, and fatal
# to critical.
qt_to_logging = {
QtCore.QtDebugMsg: logging.DEBUG,
QtCore.QtWarningMsg: logging.WARNING,
QtCore.QtCriticalMsg: logging.ERROR,
QtCore.QtFatalMsg: logging.CRITICAL,
}
try:
# pylint: disable=no-member,useless-suppression
qt_to_logging[QtCore.QtInfoMsg] = logging.INFO
except AttributeError:
# Qt < 5.5
pass
# Change levels of some well-known messages to debug so they don't get
# shown to the user.
#
# If a message starts with any text in suppressed_msgs, it's not logged as
# error.
suppressed_msgs = [
# PNGs in Qt with broken color profile
# https://bugreports.qt.io/browse/QTBUG-39788
'libpng warning: iCCP: Not recognizing known sRGB profile that has '
'been edited', # flake8: disable=E131
'libpng warning: iCCP: known incorrect sRGB profile',
# Hopefully harmless warning
'OpenType support missing for script ',
# Error if a QNetworkReply gets two different errors set. Harmless Qt
# bug on some pages.
# https://bugreports.qt.io/browse/QTBUG-30298
'QNetworkReplyImplPrivate::error: Internal problem, this method must '
'only be called once.',
# Sometimes indicates missing text, but most of the time harmless
'load glyph failed ',
# Harmless, see https://bugreports.qt.io/browse/QTBUG-42479
'content-type missing in HTTP POST, defaulting to '
'application/x-www-form-urlencoded. '
'Use QNetworkRequest::setHeader() to fix this problem.',
# https://bugreports.qt.io/browse/QTBUG-43118
'Using blocking call!',
# Hopefully harmless
'"Method "GetAll" with signature "s" on interface '
'"org.freedesktop.DBus.Properties" doesn\'t exist',
'"Method \\"GetAll\\" with signature \\"s\\" on interface '
'\\"org.freedesktop.DBus.Properties\\" doesn\'t exist\\n"',
'WOFF support requires QtWebKit to be built with zlib support.',
# Weird Enlightment/GTK X extensions
'QXcbWindow: Unhandled client message: "_E_',
'QXcbWindow: Unhandled client message: "_ECORE_',
'QXcbWindow: Unhandled client message: "_GTK_',
# Happens on AppVeyor CI
'SetProcessDpiAwareness failed:',
# https://bugreports.qt.io/browse/QTBUG-49174
'QObject::connect: Cannot connect (null)::stateChanged('
'QNetworkSession::State) to '
'QNetworkReplyHttpImpl::_q_networkSessionStateChanged('
'QNetworkSession::State)',
# https://bugreports.qt.io/browse/QTBUG-53989
"Image of format '' blocked because it is not considered safe. If you "
"are sure it is safe to do so, you can white-list the format by "
"setting the environment variable QTWEBKIT_IMAGEFORMAT_WHITELIST=",
# Installing Qt from the installer may cause it looking for SSL3 which
# may not be available on the system
"QSslSocket: cannot resolve SSLv3_client_method",
"QSslSocket: cannot resolve SSLv3_server_method",
# When enabling debugging with QtWebEngine
"Remote debugging server started successfully. Try pointing a "
"Chromium-based browser to ",
# https://github.com/The-Compiler/qutebrowser/issues/1287
"QXcbClipboard: SelectionRequest too old",
]
if sys.platform == 'darwin':
suppressed_msgs += [
'libpng warning: iCCP: known incorrect sRGB profile',
# https://bugreports.qt.io/browse/QTBUG-47154
'virtual void QSslSocketBackendPrivate::transmit() SSLRead failed '
'with: -9805', # flake8: disable=E131
]
# Messages which will trigger an exception immediately
critical_msgs = [
'Could not parse stylesheet of object',
]
if any(msg.strip().startswith(pattern) for pattern in critical_msgs):
# For some reason, the stack gets lost when raising here...
logger = logging.getLogger('misc')
logger.error("Got critical Qt warning!", stack_info=True)
raise CriticalQtWarning(msg)
elif any(msg.strip().startswith(pattern) for pattern in suppressed_msgs):
level = logging.DEBUG
else:
level = qt_to_logging[msg_type]
if context.function is None:
func = 'none'
elif ':' in context.function:
func = '"{}"'.format(context.function)
else:
func = context.function
if context.category is None or context.category == 'default':
name = 'qt'
else:
name = 'qt-' + context.category
if msg.splitlines()[0] == ('This application failed to start because it '
'could not find or load the Qt platform plugin '
'"xcb".'):
# Handle this message specially.
msg += ("\n\nOn Archlinux, this should fix the problem:\n"
" pacman -S libxkbcommon-x11")
faulthandler.disable()
stack = ''.join(traceback.format_stack())
record = qt.makeRecord(name, level, context.file, context.line, msg, None,
None, func, sinfo=stack)
qt.handle(record)
def reliability_guard(maximum_memory_bytes=None):
"""
This disables various destructive functions and prevents the generated code
from interfering with the test (e.g. fork bomb, killing other processes,
removing filesystem files, etc.)
WARNING
This function is NOT a security sandbox. Untrusted code, including, model-
generated code, should not be blindly executed outside of one. See the
Codex paper for more information about OpenAI's code sandbox, and proceed
with caution.
"""
if maximum_memory_bytes is not None:
import resource
resource.setrlimit(resource.RLIMIT_AS,
(maximum_memory_bytes, maximum_memory_bytes))
resource.setrlimit(resource.RLIMIT_DATA,
(maximum_memory_bytes, maximum_memory_bytes))
if not platform.uname().system == "Darwin":
resource.setrlimit(resource.RLIMIT_STACK,
(maximum_memory_bytes, maximum_memory_bytes))
faulthandler.disable()
import builtins
builtins.exit = None
builtins.quit = None
import os
os.environ["OMP_NUM_THREADS"] = "1"
os.kill = None
os.system = None
os.putenv = None
os.remove = None
os.removedirs = None
os.rmdir = None
os.fchdir = None
os.setuid = None
os.fork = None
os.forkpty = None
os.killpg = None
os.rename = None
os.renames = None
os.truncate = None
os.replace = None
os.unlink = None
os.fchmod = None
os.fchown = None
os.chmod = None
os.chown = None
os.chroot = None
os.fchdir = None
os.lchflags = None
os.lchmod = None
os.lchown = None
os.getcwd = None
os.chdir = None
import shutil
shutil.rmtree = None
shutil.move = None
shutil.chown = None
import subprocess
subprocess.Popen = None # type: ignore
__builtins__["help"] = None
import sys
sys.modules["ipdb"] = None
sys.modules["joblib"] = None
sys.modules["resource"] = None
sys.modules["psutil"] = None
sys.modules["tkinter"] = None
def __init__(self, cores=None, version=None, port=None, host='localhost'):
# Make sure this is the one and only client.
if jpype.isJVMStarted():
error = 'Only one client can be instantiated at a time.'
logger.error(error)
raise NotImplementedError(error)
# Discover Comsol back-end.
backend = discovery.backend(version)
# Instruct Comsol to limit number of processor cores to use.
if cores:
os.environ['COMSOL_NUM_THREADS'] = str(cores)
# On Windows, turn off fault handlers if enabled.
# Without this, pyTest will crash when starting the Java VM.
# See "Errors reported by Python fault handler" in JPype docs.
# The problem may be the SIGSEGV signal, see JPype issue #886.
if platform.system() == 'Windows' and faulthandler.is_enabled():
logger.debug('Turning off Python fault handlers.')
faulthandler.disable()
# Start the Java virtual machine.
logger.debug(f'JPype version is {jpype.__version__}.')
logger.info('Starting Java virtual machine.')
java_args = [str(backend['jvm'])]
if option('classkit'):
java_args += ['-Dcs.ckl']
logger.debug(f'JVM arguments: {java_args}')
jpype.startJVM(*java_args,
classpath=str(backend['root'] / 'plugins' / '*'),
convertStrings=False)
logger.info('Java virtual machine has started.')
# Initialize a stand-alone client if no server port given.
from com.comsol.model.util import ModelUtil as java
if port is None:
logger.info('Initializing stand-alone client.')
check_environment(backend)
graphics = True
java.initStandalone(graphics)
logger.info('Stand-alone client initialized.')
# Otherwise skip stand-alone initialization and connect to server.
else:
logger.info(f'Connecting to server "{host}" at port {port}.')
java.connect(host, port)
# Log number of used processor cores as reported by Comsol instance.
cores = java.getPreference('cluster.processor.numberofprocessors')
cores = int(str(cores))
noun = 'core' if cores == 1 else 'cores'
logger.info(f'Running on {cores} processor {noun}.')
# Load Comsol settings from disk so as to not just use defaults.
java.loadPreferences()
# Override certain settings not useful in headless operation.
java.setPreference('updates.update.check', 'off')
java.setPreference('tempfiles.saving.warnifoverwriteolder', 'off')
java.setPreference('tempfiles.recovery.autosave', 'off')
try:
# Preference not defined on certain systems, see issue #39.
java.setPreference('tempfiles.recovery.checkforrecoveries', 'off')
except Exception:
logger.debug('Could not turn off check for recovery files.')
java.setPreference('tempfiles.saving.optimize', 'filesize')
# Save useful information in instance attributes.
self.version = backend['name']
self.cores = cores
self.host = host
self.port = port
self.java = java
from __future__ import with_statement
from contextlib import contextmanager
import faulthandler; faulthandler.disable()
import os
import re
import signal
import subprocess
import sys
import tempfile
import unittest
Py_REF_DEBUG = hasattr(sys, 'gettotalrefcount')
try:
skipIf = unittest.skipIf
except AttributeError:
import functools
def skipIf(test, reason):
def decorator(func):
@functools.wraps(func)
def wrapper(*args, **kw):
if not test:
return func(*args, **kw)
else:
print("skip %s: %s" % (func.__name__, reason))
return wrapper
return decorator
def decode_output(output):
return output.decode('ascii', 'backslashreplace')
def qt_message_handler(msg_type, context, msg):
"""Qt message handler to redirect qWarning etc. to the logging system.
Args:
QtMsgType msg_type: The level of the message.
QMessageLogContext context: The source code location of the message.
msg: The message text.
"""
# Mapping from Qt logging levels to the matching logging module levels.
# Note we map critical to ERROR as it's actually "just" an error, and fatal
# to critical.
qt_to_logging = {
QtCore.QtDebugMsg: logging.DEBUG,
QtCore.QtWarningMsg: logging.WARNING,
QtCore.QtCriticalMsg: logging.ERROR,
QtCore.QtFatalMsg: logging.CRITICAL,
}
try:
# pylint: disable=no-member
qt_to_logging[QtCore.QtInfoMsg] = logging.INFO
except AttributeError:
# Qt < 5.5
pass
# Change levels of some well-known messages to debug so they don't get
# shown to the user.
#
# If a message starts with any text in suppressed_msgs, it's not logged as
# error.
suppressed_msgs = [
# PNGs in Qt with broken color profile
# https://bugreports.qt.io/browse/QTBUG-39788
'libpng warning: iCCP: Not recognizing known sRGB profile that has '
'been edited', # noqa
# Hopefully harmless warning
'OpenType support missing for script ',
# Error if a QNetworkReply gets two different errors set. Harmless Qt
# bug on some pages.
# https://bugreports.qt.io/browse/QTBUG-30298
'QNetworkReplyImplPrivate::error: Internal problem, this method must '
'only be called once.',
# Sometimes indicates missing text, but most of the time harmless
'load glyph failed ',
# Harmless, see https://bugreports.qt.io/browse/QTBUG-42479
'content-type missing in HTTP POST, defaulting to '
'application/x-www-form-urlencoded. '
'Use QNetworkRequest::setHeader() to fix this problem.',
# https://bugreports.qt.io/browse/QTBUG-43118
'Using blocking call!',
# Hopefully harmless
'"Method "GetAll" with signature "s" on interface '
'"org.freedesktop.DBus.Properties" doesn\'t exist',
'WOFF support requires QtWebKit to be built with zlib support.',
# Weird Enlightment/GTK X extensions
'QXcbWindow: Unhandled client message: "_E_',
'QXcbWindow: Unhandled client message: "_ECORE_',
'QXcbWindow: Unhandled client message: "_GTK_',
# Happens on AppVeyor CI
'SetProcessDpiAwareness failed:',
]
if sys.platform == 'darwin':
suppressed_msgs += [
'libpng warning: iCCP: known incorrect sRGB profile',
# https://bugreports.qt.io/browse/QTBUG-47154
'virtual void QSslSocketBackendPrivate::transmit() SSLRead failed '
'with: -9805', # noqa
]
if any(msg.strip().startswith(pattern) for pattern in suppressed_msgs):
level = logging.DEBUG
else:
level = qt_to_logging[msg_type]
if context.function is None:
func = 'none'
else:
func = context.function
if context.category is None or context.category == 'default':
name = 'qt'
else:
name = 'qt-' + context.category
if msg.splitlines()[0] == ('This application failed to start because it '
'could not find or load the Qt platform plugin '
'"xcb".'):
# Handle this message specially.
msg += ("\n\nOn Archlinux, this should fix the problem:\n"
" pacman -S libxkbcommon-x11")
faulthandler.disable()
stack = ''.join(traceback.format_stack())
record = qt.makeRecord(name, level, context.file, context.line, msg, None,
None, func, sinfo=stack)
qt.handle(record)
def qt_message_handler(msg_type, context, msg):
"""Qt message handler to redirect qWarning etc. to the logging system.
Args:
QtMsgType msg_type: The level of the message.
QMessageLogContext context: The source code location of the message.
msg: The message text.
"""
# Mapping from Qt logging levels to the matching logging module levels.
# Note we map critical to ERROR as it's actually "just" an error, and fatal
# to critical.
qt_to_logging = {
QtCore.QtDebugMsg: logging.DEBUG,
QtCore.QtWarningMsg: logging.WARNING,
QtCore.QtCriticalMsg: logging.ERROR,
QtCore.QtFatalMsg: logging.CRITICAL,
}
try:
# pylint: disable=no-member
qt_to_logging[QtCore.QtInfoMsg] = logging.INFO
except AttributeError:
# Qt < 5.5
pass
# Change levels of some well-known messages to debug so they don't get
# shown to the user.
# suppressed_msgs is a list of regexes matching the message texts to hide.
suppressed_msgs = (
# PNGs in Qt with broken color profile
# https://bugreports.qt-project.org/browse/QTBUG-39788
"libpng warning: iCCP: Not recognizing known sRGB profile that has "
"been edited",
# Hopefully harmless warning
"OpenType support missing for script ",
# Error if a QNetworkReply gets two different errors set. Harmless Qt
# bug on some pages.
# https://bugreports.qt-project.org/browse/QTBUG-30298
"QNetworkReplyImplPrivate::error: Internal problem, this method must "
"only be called once.",
# Not much information about this, but it seems harmless
'QXcbWindow: Unhandled client message: "_GTK_LOAD_ICONTHEMES"',
# Sometimes indicates missing text, but most of the time harmless
"load glyph failed ",
# Harmless, see https://bugreports.qt-project.org/browse/QTBUG-42479
"content-type missing in HTTP POST, defaulting to "
"application/x-www-form-urlencoded. Use QNetworkRequest::setHeader() "
"to fix this problem.",
# https://bugreports.qt-project.org/browse/QTBUG-43118
"Using blocking call!",
# Hopefully harmless
'"Method "GetAll" with signature "s" on interface '
'"org.freedesktop.DBus.Properties" doesn\'t exist',
'WOFF support requires QtWebKit to be built with zlib support.'
)
if any(msg.strip().startswith(pattern) for pattern in suppressed_msgs):
level = logging.DEBUG
else:
level = qt_to_logging[msg_type]
if context.function is None:
func = 'none'
else:
func = context.function
if context.category is None or context.category == 'default':
name = 'qt'
else:
name = 'qt-' + context.category
if msg.splitlines()[0] == ('This application failed to start because it '
'could not find or load the Qt platform plugin '
'"xcb".'):
# Handle this message specially.
msg += ("\n\nOn Archlinux, this should fix the problem:\n"
" pacman -S libxkbcommon-x11")
faulthandler.disable()
stack = ''.join(traceback.format_stack())
record = qt.makeRecord(name, level, context.file, context.line, msg, None,
None, func, sinfo=stack)
qt.handle(record)
def disable_faulthandler():
try:
import faulthandler
faulthandler.disable()
except:
pass
import ctypes as C
import faulthandler
if __name__ == "__main__":
faulthandler.enable()
Topic = C.pydll.LoadLibrary(
'/home/aynur/Repos/PubSubCPP/release/libclap_pubsub.so')
print(dir(Topic))
# print(f"TopSZ: {}")
sz = Topic.TopSZ()
name = C.byref(C.create_string_buffer(b'CLAP_PYTHON_topic2'))
print(bool(Topic.remove_topic(name)))
create = Topic.create_topic
create.restype = C.c_bool
msg_size = Topic.msg_size
msg_size.restype = C.c_uint32
t = C.byref(C.create_string_buffer(b"", size=sz))
print("CREATE:", create(t, name, 8, 8))
# t = C.c_void_p(t)
# t = C.byref(t)
print(Topic.is_null(t))
print(Topic.msg_size(t))
str_msg = b'HelloAAAAAAWorld'
lmsg = len(str_msg)
msg = C.byref(C.create_string_buffer(str_msg, size=64))
print(Topic.write(t, str_msg, 0))
print(Topic.read(t, msg))
# Topic.free_mem(tref)
faulthandler.disable()
def qt_message_handler(msg_type, context, msg):
"""Qt message handler to redirect qWarning etc. to the logging system.
Args:
QtMsgType msg_type: The level of the message.
QMessageLogContext context: The source code location of the message.
msg: The message text.
"""
# Mapping from Qt logging levels to the matching logging module levels.
# Note we map critical to ERROR as it's actually "just" an error, and fatal
# to critical.
qt_to_logging = {
QtCore.QtDebugMsg: logging.DEBUG,
QtCore.QtWarningMsg: logging.WARNING,
QtCore.QtCriticalMsg: logging.ERROR,
QtCore.QtFatalMsg: logging.CRITICAL,
}
try:
# pylint: disable=no-member,useless-suppression
qt_to_logging[QtCore.QtInfoMsg] = logging.INFO
except AttributeError:
# Qt < 5.5
pass
# Change levels of some well-known messages to debug so they don't get
# shown to the user.
#
# If a message starts with any text in suppressed_msgs, it's not logged as
# error.
suppressed_msgs = [
# PNGs in Qt with broken color profile
# https://bugreports.qt.io/browse/QTBUG-39788
"libpng warning: iCCP: Not recognizing known sRGB profile that has " "been edited", # flake8: disable=E131
"libpng warning: iCCP: known incorrect sRGB profile",
# Hopefully harmless warning
"OpenType support missing for script ",
# Error if a QNetworkReply gets two different errors set. Harmless Qt
# bug on some pages.
# https://bugreports.qt.io/browse/QTBUG-30298
"QNetworkReplyImplPrivate::error: Internal problem, this method must " "only be called once.",
# Sometimes indicates missing text, but most of the time harmless
"load glyph failed ",
# Harmless, see https://bugreports.qt.io/browse/QTBUG-42479
"content-type missing in HTTP POST, defaulting to "
"application/x-www-form-urlencoded. "
"Use QNetworkRequest::setHeader() to fix this problem.",
# https://bugreports.qt.io/browse/QTBUG-43118
"Using blocking call!",
# Hopefully harmless
'"Method "GetAll" with signature "s" on interface ' '"org.freedesktop.DBus.Properties" doesn\'t exist',
'"Method \\"GetAll\\" with signature \\"s\\" on interface '
'\\"org.freedesktop.DBus.Properties\\" doesn\'t exist\\n"',
"WOFF support requires QtWebKit to be built with zlib support.",
# Weird Enlightment/GTK X extensions
'QXcbWindow: Unhandled client message: "_E_',
'QXcbWindow: Unhandled client message: "_ECORE_',
'QXcbWindow: Unhandled client message: "_GTK_',
# Happens on AppVeyor CI
"SetProcessDpiAwareness failed:",
# https://bugreports.qt.io/browse/QTBUG-49174
"QObject::connect: Cannot connect (null)::stateChanged("
"QNetworkSession::State) to "
"QNetworkReplyHttpImpl::_q_networkSessionStateChanged("
"QNetworkSession::State)",
]
if sys.platform == "darwin":
suppressed_msgs += [
"libpng warning: iCCP: known incorrect sRGB profile",
# https://bugreports.qt.io/browse/QTBUG-47154
"virtual void QSslSocketBackendPrivate::transmit() SSLRead failed " "with: -9805", # flake8: disable=E131
]
# Messages which will trigger an exception immediately
critical_msgs = ["Could not parse stylesheet of object"]
if any(msg.strip().startswith(pattern) for pattern in critical_msgs):
# For some reason, the stack gets lost when raising here...
logger = logging.getLogger("misc")
logger.error("Got critical Qt warning!", stack_info=True)
raise CriticalQtWarning(msg)
elif any(msg.strip().startswith(pattern) for pattern in suppressed_msgs):
level = logging.DEBUG
else:
level = qt_to_logging[msg_type]
if context.function is None:
func = "none"
elif ":" in context.function:
func = '"{}"'.format(context.function)
else:
func = context.function
if context.category is None or context.category == "default":
name = "qt"
else:
name = "qt-" + context.category
if msg.splitlines()[0] == (
"This application failed to start because it " "could not find or load the Qt platform plugin " '"xcb".'
):
# Handle this message specially.
msg += "\n\nOn Archlinux, this should fix the problem:\n" " pacman -S libxkbcommon-x11"
faulthandler.disable()
stack = "".join(traceback.format_stack())
record = qt.makeRecord(name, level, context.file, context.line, msg, None, None, func, sinfo=stack)
qt.handle(record)
def _disable_faulthandler(cls):
if cls.faulthandler_signum:
faulthandler.unregister(cls.faulthandler_signum)
faulthandler.disable()
cls.faulthandler_signum = None
def qt_message_handler(msg_type, context, msg):
"""Qt message handler to redirect qWarning etc. to the logging system.
Args:
QtMsgType msg_type: The level of the message.
QMessageLogContext context: The source code location of the message.
msg: The message text.
"""
# Mapping from Qt logging levels to the matching logging module levels.
# Note we map critical to ERROR as it's actually "just" an error, and fatal
# to critical.
qt_to_logging = {
QtDebugMsg: logging.DEBUG,
QtWarningMsg: logging.WARNING,
QtCriticalMsg: logging.ERROR,
QtFatalMsg: logging.CRITICAL,
}
# Change levels of some well-known messages to debug so they don't get
# shown to the user.
# suppressed_msgs is a list of regexes matching the message texts to hide.
suppressed_msgs = (
# PNGs in Qt with broken color profile
# https://bugreports.qt-project.org/browse/QTBUG-39788
"libpng warning: iCCP: Not recognizing known sRGB profile that has "
"been edited",
# Hopefully harmless warning
"OpenType support missing for script ",
# Error if a QNetworkReply gets two different errors set. Harmless Qt
# bug on some pages.
# https://bugreports.qt-project.org/browse/QTBUG-30298
"QNetworkReplyImplPrivate::error: Internal problem, this method must "
"only be called once.",
# Not much information about this, but it seems harmless
'QXcbWindow: Unhandled client message: "_GTK_LOAD_ICONTHEMES"',
# Sometimes indicates missing text, but most of the time harmless
"load glyph failed ",
# Harmless, see https://bugreports.qt-project.org/browse/QTBUG-42479
"content-type missing in HTTP POST, defaulting to "
"application/x-www-form-urlencoded. Use QNetworkRequest::setHeader() "
"to fix this problem.")
if any(msg.strip().startswith(pattern) for pattern in suppressed_msgs):
level = logging.DEBUG
else:
level = qt_to_logging[msg_type]
if context.function is None:
func = 'none'
else:
func = context.function
if context.category is None or context.category == 'default':
name = 'qt'
else:
name = 'qt-' + context.category
if msg.splitlines()[0] == ('This application failed to start because it '
'could not find or load the Qt platform plugin '
'"xcb".'):
# Handle this message specially.
msg += ("\n\nOn Archlinux, this should fix the problem:\n"
" pacman -S libxkbcommon-x11")
faulthandler.disable()
record = qt.makeRecord(name, level, context.file, context.line, msg, None,
None, func)
qt.handle(record)
def main() -> int:
"""Start Home Assistant."""
validate_python()
# Run a simple daemon runner process on Windows to handle restarts
if os.name == "nt" and "--runner" not in sys.argv:
nt_args = cmdline() + ["--runner"]
while True:
try:
subprocess.check_call(nt_args)
sys.exit(0)
except KeyboardInterrupt:
sys.exit(0)
except subprocess.CalledProcessError as exc:
if exc.returncode != RESTART_EXIT_CODE:
sys.exit(exc.returncode)
args = get_arguments()
if args.script is not None:
# pylint: disable=import-outside-toplevel
from . import scripts
return scripts.run(args.script)
config_dir = os.path.abspath(os.path.join(os.getcwd(), args.config))
ensure_config_path(config_dir)
# Daemon functions
if args.pid_file:
check_pid(args.pid_file)
if args.daemon:
daemonize()
if args.pid_file:
write_pid(args.pid_file)
# pylint: disable=import-outside-toplevel
from . import runner
runtime_conf = runner.RuntimeConfig(
config_dir=config_dir,
verbose=args.verbose,
log_rotate_days=args.log_rotate_days,
log_file=args.log_file,
log_no_color=args.log_no_color,
skip_pip=args.skip_pip,
safe_mode=args.safe_mode,
debug=args.debug,
open_ui=args.open_ui,
)
fault_file_name = os.path.join(config_dir, FAULT_LOG_FILENAME)
with open(fault_file_name, mode="a", encoding="utf8") as fault_file:
faulthandler.enable(fault_file)
exit_code = runner.run(runtime_conf)
faulthandler.disable()
if os.path.getsize(fault_file_name) == 0:
os.remove(fault_file_name)
if exit_code == RESTART_EXIT_CODE and not args.runner:
try_to_restart()
return exit_code
top-level directory of this distribution and at <https://github.com/Ulm-IQO/qudi/>
Derived form ACQ4:
Copyright 2010 Luke Campagnola
Originally distributed under MIT/X11 license. See documentation/MITLicense.txt for more infomation.
"""
import sys
import os
# Enable stack trace output for SIGSEGV, SIGFPE, SIGABRT, SIGBUS,
# and SIGILL signals
# -> e.g. for segmentation faults
import faulthandler
faulthandler.disable()
faulthandler.enable(all_threads=True)
# parse commandline parameters
import argparse
parser = argparse.ArgumentParser(prog='start.py')
group = parser.add_mutually_exclusive_group()
group.add_argument('-p', '--profile', action='store_true',
help='enables profiler')
group.add_argument('-cg', '--callgraph', action='store_true',
help='display dependencies between the methods/modules')
parser.add_argument('-m', '--manhole', action='store_true',
help='manhole for debugging purposes')
parser.add_argument('-g', '--no-gui', action='store_true',
help='does not load the manager gui module')
def main(args):
'''the main encoder function'''
checkParams(args)
download_dir = 'http://bioinformatics.org/spower/download/.private'
downloadResources([('{}/genemap.txt'.format(download_dir), env.resource_dir),
('{}/{}/mlink'.format(download_dir, platform.system().lower()), env.resource_bin),
('{}/{}/unknown'.format(download_dir, platform.system().lower()), env.resource_bin),
('{}/{}/makeped'.format(download_dir, platform.system().lower()), env.resource_bin),
('{}/{}/pedcheck'.format(download_dir, platform.system().lower()), env.resource_bin)])
if args.no_save:
cache = NoCache()
else:
cache = Cache(env.cache_dir, env.output, vars(args))
cache.setID('vcf')
# STEP 1: write encoded data to TPED format
if not args.vanilla and cache.check():
env.log('Loading regional marker data from archive ...')
cache.load(target_dir = env.tmp_dir, names = ['CACHE'])
env.success_counter.value = sum(map(fileLinesCount, glob.glob('{}/*.tped'.format(env.tmp_cache))))
env.batch = 10
else:
# load VCF file header
checkVCFBundle(args.vcf)
cache.clear()
try:
vs = cstatgen.VCFstream(args.vcf)
except Exception as e:
env.error("{}".format(e), exit = True)
samples_vcf = vs.GetSampleNames()
if len(samples_vcf) == 0:
env.error("Fail to extract samples from [{}]".format(args.vcf), exit = True)
env.log('{:,d} samples found in [{}]'.format(len(samples_vcf), args.vcf))
samples_not_vcf = checkSamples(samples_vcf, getColumn(args.tfam, 2))[1]
# load sample info
data = RData(samples_vcf, TFAMParser(args.tfam))
if len(data.families) == 0:
env.error('No valid family to process. ' \
'Families have to be at least trio with at least one member in VCF file.', exit = True)
if len(data.samples) == 0:
env.error('No valid sample to process. ' \
'Samples have to be in families, and present in both TFAM and VCF files.', exit = True)
rewriteFamfile(os.path.join(env.tmp_cache, '{}.tfam'.format(env.output)),
data.tfam.samples, data.samples.keys() + samples_not_vcf)
if args.single_markers:
regions = [(x[0], x[1], x[1], "{}:{}".format(x[0], x[1]), '.', '.', '.')
for x in vs.GetGenomeCoordinates()]
args.blueprint = None
else:
# load blueprint
try:
env.log('Loading marker map from [{}] ...'.format(args.blueprint))
with open(args.blueprint, 'r') as f:
regions = [x.strip().split() for x in f.readlines()]
except IOError:
env.error("Cannot load regional marker blueprint [{}]. ".format(args.blueprint), exit = True)
env.log('{:,d} families with a total of {:,d} samples will be scanned for {:,d} pre-defined units'.\
format(len(data.families), len(data.samples), len(regions)))
env.jobs = max(min(args.jobs, len(regions)), 1)
regions.extend([None] * env.jobs)
queue = Queue()
try:
faulthandler.enable(file=open(env.tmp_log + '.SEGV', 'w'))
for i in regions:
queue.put(i)
jobs = [EncoderWorker(
queue, len(regions), deepcopy(data),
RegionExtractor(args.vcf, chr_prefix = args.chr_prefix, allele_freq_info = args.freq),
MarkerMaker(args.bin, maf_cutoff = args.maf_cutoff),
LinkageWriter(len(samples_not_vcf))
) for i in range(env.jobs)]
for j in jobs:
j.start()
for j in jobs:
j.join()
faulthandler.disable()
except KeyboardInterrupt:
# FIXME: need to properly close all jobs
raise ValueError("Use 'killall {}' to properly terminate all processes!".format(env.prog))
else:
env.log('{:,d} units (from {:,d} variants) processed; '\
'{:,d} Mendelian inconsistencies and {:,d} recombination events handled\n'.\
format(env.success_counter.value,
env.variants_counter.value,
env.mendelerror_counter.value,
env.recomb_counter.value), flush = True)
if env.triallelic_counter.value:
env.log('{:,d} tri-allelic loci were ignored'.format(env.triallelic_counter.value))
if env.commonvar_counter.value:
env.log('{:,d} variants ignored due to having MAF > {}'.\
format(env.commonvar_counter.value, args.maf_cutoff))
if env.null_counter.value:
env.log('{:,d} units ignored due to absence in VCF file'.format(env.null_counter.value))
if env.trivial_counter.value:
env.log('{:,d} units ignored due to absence of variation in samples'.format(env.trivial_counter.value))
fatal_errors = 0
try:
# Error msg from C++ extension
os.system("cat {}/*.* > {}".format(env.tmp_dir, env.tmp_log))
fatal_errors = wordCount(env.tmp_log)['fatal']
except KeyError:
pass
if env.chperror_counter.value:
env.error("{:,d} regional markers failed to be generated due to haplotyping failures!".\
format(env.chperror_counter.value))
if fatal_errors:
env.error("{:,d} or more regional markers failed to be generated due to runtime errors!".\
format(fatal_errors))
env.log('Archiving regional marker data to directory [{}]'.format(env.cache_dir))
cache.write(arcroot = 'CACHE', source_dir = env.tmp_cache)
env.jobs = args.jobs
# STEP 2: write to PLINK or mega2 format
tpeds = [os.path.join(env.tmp_cache, item) for item in os.listdir(env.tmp_cache) if item.startswith(env.output) and item.endswith('.tped')]
for fmt in args.format:
cache.setID(fmt)
if not args.vanilla and cache.check():
env.log('Loading {} data from archive ...'.format(fmt.upper()))
cache.load(target_dir = env.tmp_dir, names = [fmt.upper()])
else:
env.log('{:,d} units will be converted to {} format'.format(env.success_counter.value, fmt.upper()))
env.format_counter.value = 0
format(tpeds, os.path.join(env.tmp_cache, "{}.tfam".format(env.output)),
args.prevalence, args.wild_pen, args.muta_pen, fmt,
args.inherit_mode, args.theta_max, args.theta_inc)
env.log('{:,d} units successfully converted to {} format\n'.\
format(env.format_counter.value, fmt.upper()), flush = True)
if env.skipped_counter.value:
# FIXME: perhaps we need to rephrase this message?
env.log('{} region - family pairs skipped'.\
format(env.skipped_counter.value))
env.log('Archiving {} format to directory [{}]'.format(fmt.upper(), env.cache_dir))
cache.write(arcroot = fmt.upper(),
source_dir = os.path.join(env.tmp_dir, fmt.upper()), mode = 'a')
mkpath(env.outdir)
if args.run_linkage:
cache.setID('analysis')
if not args.vanilla and cache.check():
env.log('Loading linkage analysis result from archive ...'.format(fmt.upper()))
cache.load(target_dir = env.output, names = ['heatmap'])
else:
env.log('Running linkage analysis ...'.format(fmt.upper()))
run_linkage(args.blueprint, args.theta_inc, args.theta_max, args.output_limit)
env.log('Linkage analysis succesfully performed for {:,d} units\n'.\
format(env.run_counter.value, fmt.upper()), flush = True)
if env.makeped_counter.value:
env.log('{} "makeped" runtime errors occurred'.format(env.makeped_counter.value))
if env.pedcheck_counter.value:
env.log('{} "pedcheck" runtime errors occurred'.format(env.pedcheck_counter.value))
if env.unknown_counter.value:
env.log('{} "unknown" runtime errors occurred'.format(env.unknown_counter.value))
if env.mlink_counter.value:
env.log('{} "mlink" runtime errors occurred'.format(env.mlink_counter.value))
cache.write(arcroot = 'heatmap', source_dir = os.path.join(env.output, 'heatmap'), mode = 'a')
html(args.theta_inc, args.theta_max, args.output_limit)
else:
env.log('Saving data to [{}]'.format(os.path.abspath(env.output)))
cache.load(target_dir = env.output)
def qt_message_handler(msg_type, context, msg):
"""Qt message handler to redirect qWarning etc. to the logging system.
Args:
QtMsgType msg_type: The level of the message.
QMessageLogContext context: The source code location of the message.
msg: The message text.
"""
# Mapping from Qt logging levels to the matching logging module levels.
# Note we map critical to ERROR as it's actually "just" an error, and fatal
# to critical.
qt_to_logging = {
QtCore.QtDebugMsg: logging.DEBUG,
QtCore.QtWarningMsg: logging.WARNING,
QtCore.QtCriticalMsg: logging.ERROR,
QtCore.QtFatalMsg: logging.CRITICAL,
}
try:
# pylint: disable=no-member
qt_to_logging[QtCore.QtInfoMsg] = logging.INFO
except AttributeError:
# Qt < 5.5
pass
# Change levels of some well-known messages to debug so they don't get
# shown to the user.
# suppressed_msgs is a list of regexes matching the message texts to hide.
suppressed_msgs = (
# PNGs in Qt with broken color profile
# https://bugreports.qt.io/browse/QTBUG-39788
"libpng warning: iCCP: Not recognizing known sRGB profile that has "
"been edited",
# Hopefully harmless warning
"OpenType support missing for script ",
# Error if a QNetworkReply gets two different errors set. Harmless Qt
# bug on some pages.
# https://bugreports.qt.io/browse/QTBUG-30298
"QNetworkReplyImplPrivate::error: Internal problem, this method must "
"only be called once.",
# Sometimes indicates missing text, but most of the time harmless
"load glyph failed ",
# Harmless, see https://bugreports.qt.io/browse/QTBUG-42479
"content-type missing in HTTP POST, defaulting to "
"application/x-www-form-urlencoded. Use QNetworkRequest::setHeader() "
"to fix this problem.",
# https://bugreports.qt.io/browse/QTBUG-43118
"Using blocking call!",
# Hopefully harmless
'"Method "GetAll" with signature "s" on interface '
'"org.freedesktop.DBus.Properties" doesn\'t exist',
'WOFF support requires QtWebKit to be built with zlib support.',
# Weird Enlightment/GTK X extensions
'QXcbWindow: Unhandled client message: "_E_',
'QXcbWindow: Unhandled client message: "_ECORE_',
'QXcbWindow: Unhandled client message: "_GTK_',
# Happens on AppVeyor CI
'SetProcessDpiAwareness failed:',
)
if any(msg.strip().startswith(pattern) for pattern in suppressed_msgs):
level = logging.DEBUG
else:
level = qt_to_logging[msg_type]
if context.function is None:
func = 'none'
else:
func = context.function
if context.category is None or context.category == 'default':
name = 'qt'
else:
name = 'qt-' + context.category
if msg.splitlines()[0] == ('This application failed to start because it '
'could not find or load the Qt platform plugin '
'"xcb".'):
# Handle this message specially.
msg += ("\n\nOn Archlinux, this should fix the problem:\n"
" pacman -S libxkbcommon-x11")
faulthandler.disable()
stack = ''.join(traceback.format_stack())
record = qt.makeRecord(name,
level,
context.file,
context.line,
msg,
None,
None,
func,
sinfo=stack)
qt.handle(record)
def main(infile, outfile):
faulthandler_log_path = os.environ.get("PYTHON_FAULTHANDLER_DIR", None)
try:
if faulthandler_log_path:
faulthandler_log_path = os.path.join(faulthandler_log_path, str(os.getpid()))
faulthandler_log_file = open(faulthandler_log_path, "w")
faulthandler.enable(file=faulthandler_log_file)
boot_time = time.time()
split_index = read_int(infile)
if split_index == -1: # for unit tests
sys.exit(-1)
version = utf8_deserializer.loads(infile)
if version != "%d.%d" % sys.version_info[:2]:
raise RuntimeError(
(
"Python in worker has different version %s than that in "
+ "driver %s, PySpark cannot run with different minor versions. "
+ "Please check environment variables PYSPARK_PYTHON and "
+ "PYSPARK_DRIVER_PYTHON are correctly set."
)
% ("%d.%d" % sys.version_info[:2], version)
)
# read inputs only for a barrier task
isBarrier = read_bool(infile)
boundPort = read_int(infile)
secret = UTF8Deserializer().loads(infile)
# set up memory limits
memory_limit_mb = int(os.environ.get("PYSPARK_EXECUTOR_MEMORY_MB", "-1"))
if memory_limit_mb > 0 and has_resource_module:
total_memory = resource.RLIMIT_AS
try:
(soft_limit, hard_limit) = resource.getrlimit(total_memory)
msg = "Current mem limits: {0} of max {1}\n".format(soft_limit, hard_limit)
print(msg, file=sys.stderr)
# convert to bytes
new_limit = memory_limit_mb * 1024 * 1024
if soft_limit == resource.RLIM_INFINITY or new_limit < soft_limit:
msg = "Setting mem limits to {0} of max {1}\n".format(new_limit, new_limit)
print(msg, file=sys.stderr)
resource.setrlimit(total_memory, (new_limit, new_limit))
except (resource.error, OSError, ValueError) as e:
# not all systems support resource limits, so warn instead of failing
lineno = (
getframeinfo(currentframe()).lineno + 1 if currentframe() is not None else 0
)
print(
warnings.formatwarning(
"Failed to set memory limit: {0}".format(e),
ResourceWarning,
__file__,
lineno,
),
file=sys.stderr,
)
# initialize global state
taskContext = None
if isBarrier:
taskContext = BarrierTaskContext._getOrCreate()
BarrierTaskContext._initialize(boundPort, secret)
# Set the task context instance here, so we can get it by TaskContext.get for
# both TaskContext and BarrierTaskContext
TaskContext._setTaskContext(taskContext)
else:
taskContext = TaskContext._getOrCreate()
# read inputs for TaskContext info
taskContext._stageId = read_int(infile)
taskContext._partitionId = read_int(infile)
taskContext._attemptNumber = read_int(infile)
taskContext._taskAttemptId = read_long(infile)
taskContext._cpus = read_int(infile)
taskContext._resources = {}
for r in range(read_int(infile)):
key = utf8_deserializer.loads(infile)
name = utf8_deserializer.loads(infile)
addresses = []
taskContext._resources = {}
for a in range(read_int(infile)):
addresses.append(utf8_deserializer.loads(infile))
taskContext._resources[key] = ResourceInformation(name, addresses)
taskContext._localProperties = dict()
for i in range(read_int(infile)):
k = utf8_deserializer.loads(infile)
v = utf8_deserializer.loads(infile)
taskContext._localProperties[k] = v
shuffle.MemoryBytesSpilled = 0
shuffle.DiskBytesSpilled = 0
_accumulatorRegistry.clear()
# fetch name of workdir
spark_files_dir = utf8_deserializer.loads(infile)
SparkFiles._root_directory = spark_files_dir
SparkFiles._is_running_on_worker = True
# fetch names of includes (*.zip and *.egg files) and construct PYTHONPATH
add_path(spark_files_dir) # *.py files that were added will be copied here
num_python_includes = read_int(infile)
for _ in range(num_python_includes):
filename = utf8_deserializer.loads(infile)
add_path(os.path.join(spark_files_dir, filename))
importlib.invalidate_caches()
# fetch names and values of broadcast variables
needs_broadcast_decryption_server = read_bool(infile)
num_broadcast_variables = read_int(infile)
if needs_broadcast_decryption_server:
# read the decrypted data from a server in the jvm
port = read_int(infile)
auth_secret = utf8_deserializer.loads(infile)
(broadcast_sock_file, _) = local_connect_and_auth(port, auth_secret)
for _ in range(num_broadcast_variables):
bid = read_long(infile)
if bid >= 0:
if needs_broadcast_decryption_server:
read_bid = read_long(broadcast_sock_file)
assert read_bid == bid
_broadcastRegistry[bid] = Broadcast(sock_file=broadcast_sock_file)
else:
path = utf8_deserializer.loads(infile)
_broadcastRegistry[bid] = Broadcast(path=path)
else:
bid = -bid - 1
_broadcastRegistry.pop(bid)
if needs_broadcast_decryption_server:
broadcast_sock_file.write(b"1")
broadcast_sock_file.close()
_accumulatorRegistry.clear()
eval_type = read_int(infile)
if eval_type == PythonEvalType.NON_UDF:
func, profiler, deserializer, serializer = read_command(pickleSer, infile)
else:
func, profiler, deserializer, serializer = read_udfs(pickleSer, infile, eval_type)
init_time = time.time()
def process():
iterator = deserializer.load_stream(infile)
out_iter = func(split_index, iterator)
try:
serializer.dump_stream(out_iter, outfile)
finally:
if hasattr(out_iter, "close"):
out_iter.close()
if profiler:
profiler.profile(process)
else:
process()
# Reset task context to None. This is a guard code to avoid residual context when worker
# reuse.
TaskContext._setTaskContext(None)
BarrierTaskContext._setTaskContext(None)
except BaseException as e:
try:
exc_info = None
if os.environ.get("SPARK_SIMPLIFIED_TRACEBACK", False):
tb = try_simplify_traceback(sys.exc_info()[-1])
if tb is not None:
e.__cause__ = None
exc_info = "".join(traceback.format_exception(type(e), e, tb))
if exc_info is None:
exc_info = traceback.format_exc()
write_int(SpecialLengths.PYTHON_EXCEPTION_THROWN, outfile)
write_with_length(exc_info.encode("utf-8"), outfile)
except IOError:
# JVM close the socket
pass
except BaseException:
# Write the error to stderr if it happened while serializing
print("PySpark worker failed with exception:", file=sys.stderr)
print(traceback.format_exc(), file=sys.stderr)
sys.exit(-1)
finally:
if faulthandler_log_path:
faulthandler.disable()
faulthandler_log_file.close()
os.remove(faulthandler_log_path)
finish_time = time.time()
report_times(outfile, boot_time, init_time, finish_time)
write_long(shuffle.MemoryBytesSpilled, outfile)
write_long(shuffle.DiskBytesSpilled, outfile)
# Mark the beginning of the accumulators section of the output
write_int(SpecialLengths.END_OF_DATA_SECTION, outfile)
write_int(len(_accumulatorRegistry), outfile)
for (aid, accum) in _accumulatorRegistry.items():
pickleSer._write_with_length((aid, accum._value), outfile)
# check end of stream
if read_int(infile) == SpecialLengths.END_OF_STREAM:
write_int(SpecialLengths.END_OF_STREAM, outfile)
else:
# write a different value to tell JVM to not reuse this worker
write_int(SpecialLengths.END_OF_DATA_SECTION, outfile)
sys.exit(-1)
def qt_message_handler(msg_type, context, msg):
"""Qt message handler to redirect qWarning etc. to the logging system.
Args:
QtMsgType msg_type: The level of the message.
QMessageLogContext context: The source code location of the message.
msg: The message text.
"""
# Mapping from Qt logging levels to the matching logging module levels.
# Note we map critical to ERROR as it's actually "just" an error, and fatal
# to critical.
qt_to_logging = {
QtCore.QtDebugMsg: logging.DEBUG,
QtCore.QtWarningMsg: logging.WARNING,
QtCore.QtCriticalMsg: logging.ERROR,
QtCore.QtFatalMsg: logging.CRITICAL,
}
try:
qt_to_logging[QtCore.QtInfoMsg] = logging.INFO
except AttributeError:
# Qt < 5.5
pass
# Change levels of some well-known messages to debug so they don't get
# shown to the user.
#
# If a message starts with any text in suppressed_msgs, it's not logged as
# error.
suppressed_msgs = [
# PNGs in Qt with broken color profile
# https://bugreports.qt.io/browse/QTBUG-39788
'libpng warning: iCCP: Not recognizing known sRGB profile that has '
'been edited', # flake8: disable=E131
'libpng warning: iCCP: known incorrect sRGB profile',
# Hopefully harmless warning
'OpenType support missing for script ',
# Error if a QNetworkReply gets two different errors set. Harmless Qt
# bug on some pages.
# https://bugreports.qt.io/browse/QTBUG-30298
'QNetworkReplyImplPrivate::error: Internal problem, this method must '
'only be called once.',
# Sometimes indicates missing text, but most of the time harmless
'load glyph failed ',
# Harmless, see https://bugreports.qt.io/browse/QTBUG-42479
'content-type missing in HTTP POST, defaulting to '
'application/x-www-form-urlencoded. '
'Use QNetworkRequest::setHeader() to fix this problem.',
# https://bugreports.qt.io/browse/QTBUG-43118
'Using blocking call!',
# Hopefully harmless
'"Method "GetAll" with signature "s" on interface '
'"org.freedesktop.DBus.Properties" doesn\'t exist',
'"Method \\"GetAll\\" with signature \\"s\\" on interface '
'\\"org.freedesktop.DBus.Properties\\" doesn\'t exist\\n"',
'WOFF support requires QtWebKit to be built with zlib support.',
# Weird Enlightment/GTK X extensions
'QXcbWindow: Unhandled client message: "_E_',
'QXcbWindow: Unhandled client message: "_ECORE_',
'QXcbWindow: Unhandled client message: "_GTK_',
# Happens on AppVeyor CI
'SetProcessDpiAwareness failed:',
# https://bugreports.qt.io/browse/QTBUG-49174
'QObject::connect: Cannot connect (null)::stateChanged('
'QNetworkSession::State) to '
'QNetworkReplyHttpImpl::_q_networkSessionStateChanged('
'QNetworkSession::State)',
# https://bugreports.qt.io/browse/QTBUG-53989
"Image of format '' blocked because it is not considered safe. If you "
"are sure it is safe to do so, you can white-list the format by "
"setting the environment variable QTWEBKIT_IMAGEFORMAT_WHITELIST=",
# Installing Qt from the installer may cause it looking for SSL3 or
# OpenSSL 1.0 which may not be available on the system
"QSslSocket: cannot resolve ",
"QSslSocket: cannot call unresolved function ",
# When enabling debugging with QtWebEngine
"Remote debugging server started successfully. Try pointing a "
"Chromium-based browser to ",
# https://github.com/qutebrowser/qutebrowser/issues/1287
"QXcbClipboard: SelectionRequest too old",
# https://github.com/qutebrowser/qutebrowser/issues/2071
'QXcbWindow: Unhandled client message: ""',
# https://codereview.qt-project.org/176831
"QObject::disconnect: Unexpected null parameter",
]
if sys.platform == 'darwin':
suppressed_msgs += [
'libpng warning: iCCP: known incorrect sRGB profile',
# https://bugreports.qt.io/browse/QTBUG-47154
'virtual void QSslSocketBackendPrivate::transmit() SSLRead failed '
'with: -9805', # flake8: disable=E131
]
if any(msg.strip().startswith(pattern) for pattern in suppressed_msgs):
level = logging.DEBUG
else:
level = qt_to_logging[msg_type]
if context.function is None:
func = 'none'
elif ':' in context.function:
func = '"{}"'.format(context.function)
else:
func = context.function
if context.category is None or context.category == 'default':
name = 'qt'
else:
name = 'qt-' + context.category
if msg.splitlines()[0] == ('This application failed to start because it '
'could not find or load the Qt platform plugin '
'"xcb".'):
# Handle this message specially.
msg += ("\n\nOn Archlinux, this should fix the problem:\n"
" pacman -S libxkbcommon-x11")
faulthandler.disable()
stack = ''.join(traceback.format_stack())
record = qt.makeRecord(name,
level,
context.file,
context.line,
msg,
None,
None,
func,
sinfo=stack)
qt.handle(record)
def test_isenabled(self):
self.assertFalse(faulthandler.isenabled())
faulthandler.enable()
self.assertTrue(faulthandler.isenabled())
faulthandler.disable()
self.assertFalse(faulthandler.isenabled())
