def test_min_window_size(raw, cfg_value):
"""Test minimum window plot size."""
old_cfg = get_config('MNE_BROWSE_RAW_SIZE')
set_config('MNE_BROWSE_RAW_SIZE', cfg_value)
fig = raw.plot()
# 8 × 8 inches is default minimum size
assert_array_equal(fig.get_size_inches(), (8, 8))
set_config('MNE_BROWSE_RAW_SIZE', old_cfg)
def test_config():
"""Test mne-python config file support"""
tempdir = _TempDir()
key = '_MNE_PYTHON_CONFIG_TESTING'
value = '123456'
old_val = os.getenv(key, None)
os.environ[key] = value
assert_true(get_config(key) == value)
del os.environ[key]
# catch the warning about it being a non-standard config key
assert_true(len(set_config(None, None)) > 10) # tuple of valid keys
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
set_config(key, None, home_dir=tempdir)
assert_true(len(w) == 1)
assert_true(get_config(key, home_dir=tempdir) is None)
assert_raises(KeyError, get_config, key, raise_error=True)
with warnings.catch_warnings(record=True):
warnings.simplefilter('always')
set_config(key, value, home_dir=tempdir)
assert_true(get_config(key, home_dir=tempdir) == value)
set_config(key, None, home_dir=tempdir)
if old_val is not None:
os.environ[key] = old_val
# Check if get_config with no input returns all config
key = 'MNE_PYTHON_TESTING_KEY'
config = {key: value}
with warnings.catch_warnings(record=True): # non-standard key
warnings.simplefilter('always')
set_config(key, value, home_dir=tempdir)
assert_equal(get_config(home_dir=tempdir), config)
def test_min_window_size(raw, cfg_value, browser_backend):
"""Test minimum window plot size."""
old_cfg = get_config('MNE_BROWSE_RAW_SIZE')
set_config('MNE_BROWSE_RAW_SIZE', cfg_value)
fig = raw.plot()
# For an unknown reason, the Windows-CI is a bit off
# (on local Windows 10 the size is exactly as expected).
atol = 0 if not os.name == 'nt' else 0.2
# 8 × 8 inches is default minimum size.
assert_allclose(fig._get_size(), (8, 8), atol=atol)
set_config('MNE_BROWSE_RAW_SIZE', old_cfg)
def test_config():
"""Test mne-python config file support"""
tempdir = _TempDir()
key = '_MNE_PYTHON_CONFIG_TESTING'
value = '123456'
old_val = os.getenv(key, None)
os.environ[key] = value
assert_true(get_config(key) == value)
del os.environ[key]
# catch the warning about it being a non-standard config key
assert_true(len(set_config(None, None)) > 10) # tuple of valid keys
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
set_config(key, None, home_dir=tempdir)
assert_true(len(w) == 1)
assert_true(get_config(key, home_dir=tempdir) is None)
assert_raises(KeyError, get_config, key, raise_error=True)
with warnings.catch_warnings(record=True):
warnings.simplefilter('always')
set_config(key, value, home_dir=tempdir)
assert_true(get_config(key, home_dir=tempdir) == value)
set_config(key, None, home_dir=tempdir)
if old_val is not None:
os.environ[key] = old_val
# Check if get_config with no input returns all config
key = 'MNE_PYTHON_TESTING_KEY'
config = {key: value}
with warnings.catch_warnings(record=True): # non-standard key
warnings.simplefilter('always')
set_config(key, value, home_dir=tempdir)
assert_equal(get_config(home_dir=tempdir), config)
# Check what happens when we use a corrupted file
json_fname = get_config_path(home_dir=tempdir)
with open(json_fname, 'w') as fid:
fid.write('foo{}')
with warnings.catch_warnings(record=True) as w:
assert_equal(get_config(home_dir=tempdir), dict())
assert_true(any('not a valid JSON' in str(ww.message) for ww in w))
with warnings.catch_warnings(record=True) as w: # non-standard key
assert_raises(RuntimeError, set_config, key, 'true', home_dir=tempdir)
def test_config():
"""Test mne-python config file support"""
tempdir = _TempDir()
key = '_MNE_PYTHON_CONFIG_TESTING'
value = '123456'
old_val = os.getenv(key, None)
os.environ[key] = value
assert_true(get_config(key) == value)
del os.environ[key]
# catch the warning about it being a non-standard config key
assert_true(len(set_config(None, None)) > 10) # tuple of valid keys
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
set_config(key, None, home_dir=tempdir)
assert_true(len(w) == 1)
assert_true(get_config(key, home_dir=tempdir) is None)
assert_raises(KeyError, get_config, key, raise_error=True)
with warnings.catch_warnings(record=True):
warnings.simplefilter('always')
set_config(key, value, home_dir=tempdir)
assert_true(get_config(key, home_dir=tempdir) == value)
set_config(key, None, home_dir=tempdir)
if old_val is not None:
os.environ[key] = old_val
# Check if get_config with no input returns all config
key = 'MNE_PYTHON_TESTING_KEY'
config = {key: value}
with warnings.catch_warnings(record=True): # non-standard key
warnings.simplefilter('always')
set_config(key, value, home_dir=tempdir)
assert_equal(get_config(home_dir=tempdir), config)
# Check what happens when we use a corrupted file
json_fname = get_config_path(home_dir=tempdir)
with open(json_fname, 'w') as fid:
fid.write('foo{}')
with warnings.catch_warnings(record=True) as w:
assert_equal(get_config(home_dir=tempdir), dict())
assert_true(any('not a valid JSON' in str(ww.message) for ww in w))
with warnings.catch_warnings(record=True) as w: # non-standard key
assert_raises(RuntimeError, set_config, key, 'true', home_dir=tempdir)
def test_config():
"""Test mne-python config file support."""
tempdir = _TempDir()
key = '_MNE_PYTHON_CONFIG_TESTING'
value = '123456'
value2 = '123'
old_val = os.getenv(key, None)
os.environ[key] = value
assert (get_config(key) == value)
del os.environ[key]
# catch the warning about it being a non-standard config key
assert (len(set_config(None, None)) > 10) # tuple of valid keys
with pytest.warns(RuntimeWarning, match='non-standard'):
set_config(key, None, home_dir=tempdir, set_env=False)
assert (get_config(key, home_dir=tempdir) is None)
pytest.raises(KeyError, get_config, key, raise_error=True)
assert (key not in os.environ)
with pytest.warns(RuntimeWarning, match='non-standard'):
set_config(key, value, home_dir=tempdir, set_env=True)
assert (key in os.environ)
assert (get_config(key, home_dir=tempdir) == value)
with pytest.warns(RuntimeWarning, match='non-standard'):
set_config(key, None, home_dir=tempdir, set_env=True)
assert (key not in os.environ)
with pytest.warns(RuntimeWarning, match='non-standard'):
set_config(key, None, home_dir=tempdir, set_env=True)
assert (key not in os.environ)
if old_val is not None:
os.environ[key] = old_val
# Check if get_config with key=None returns all config
key = 'MNE_PYTHON_TESTING_KEY'
assert key not in get_config(home_dir=tempdir)
with pytest.warns(RuntimeWarning, match='non-standard'):
set_config(key, value, home_dir=tempdir)
assert_equal(get_config(home_dir=tempdir)[key], value)
old_val = os.environ.get(key)
try: # os.environ should take precedence over config file
os.environ[key] = value2
assert_equal(get_config(home_dir=tempdir)[key], value2)
finally: # reset os.environ
if old_val is None:
os.environ.pop(key, None)
else:
os.environ[key] = old_val
# Check what happens when we use a corrupted file
json_fname = get_config_path(home_dir=tempdir)
with open(json_fname, 'w') as fid:
fid.write('foo{}')
with pytest.warns(RuntimeWarning, match='not a valid JSON'):
assert key not in get_config(home_dir=tempdir)
with pytest.warns(RuntimeWarning, match='non-standard'):
pytest.raises(RuntimeError, set_config, key, 'true', home_dir=tempdir)
def test_config(tmp_path):
"""Test mne-python config file support."""
tempdir = str(tmp_path)
key = '_MNE_PYTHON_CONFIG_TESTING'
value = '123456'
value2 = '123'
value3 = Path('/foo/bar')
old_val = os.getenv(key, None)
os.environ[key] = value
assert (get_config(key) == value)
del os.environ[key]
# catch the warning about it being a non-standard config key
assert (len(get_config('')) > 10) # tuple of valid keys
with pytest.warns(RuntimeWarning, match='non-standard'):
set_config(key, None, home_dir=tempdir, set_env=False)
assert (get_config(key, home_dir=tempdir) is None)
pytest.raises(KeyError, get_config, key, raise_error=True)
assert (key not in os.environ)
with pytest.warns(RuntimeWarning, match='non-standard'):
set_config(key, value, home_dir=tempdir, set_env=True)
assert (key in os.environ)
assert (get_config(key, home_dir=tempdir) == value)
with pytest.warns(RuntimeWarning, match='non-standard'):
set_config(key, None, home_dir=tempdir, set_env=True)
assert (key not in os.environ)
with pytest.warns(RuntimeWarning, match='non-standard'):
set_config(key, None, home_dir=tempdir, set_env=True)
assert (key not in os.environ)
if old_val is not None:
os.environ[key] = old_val
# Check serialization from Path to string
with pytest.warns(RuntimeWarning, match='non-standard'):
set_config(key, value3, home_dir=tempdir)
# Check if get_config with key=None returns all config
key = 'MNE_PYTHON_TESTING_KEY'
assert key not in get_config(home_dir=tempdir)
with pytest.warns(RuntimeWarning, match='non-standard'):
set_config(key, value, home_dir=tempdir)
assert get_config(home_dir=tempdir)[key] == value
old_val = os.environ.get(key)
try: # os.environ should take precedence over config file
os.environ[key] = value2
assert get_config(home_dir=tempdir)[key] == value2
finally: # reset os.environ
if old_val is None:
os.environ.pop(key, None)
else:
os.environ[key] = old_val
# Check what happens when we use a corrupted file
json_fname = get_config_path(home_dir=tempdir)
with open(json_fname, 'w') as fid:
fid.write('foo{}')
with pytest.warns(RuntimeWarning, match='not a valid JSON'):
assert key not in get_config(home_dir=tempdir)
with pytest.warns(RuntimeWarning, match='non-standard'):
pytest.raises(RuntimeError, set_config, key, 'true', home_dir=tempdir)
# degenerate conditions
pytest.raises(ValueError, set_memmap_min_size, 1)
pytest.raises(ValueError, set_memmap_min_size, 'foo')
pytest.raises(TypeError, get_config, 1)
pytest.raises(TypeError, set_config, 1)
pytest.raises(TypeError, set_config, 'foo', 1)
pytest.raises(TypeError, _get_stim_channel, 1, None)
pytest.raises(TypeError, _get_stim_channel, [1], None)
def test_config():
"""Test mne-python config file support."""
tempdir = _TempDir()
key = '_MNE_PYTHON_CONFIG_TESTING'
value = '123456'
value2 = '123'
old_val = os.getenv(key, None)
os.environ[key] = value
assert_true(get_config(key) == value)
del os.environ[key]
# catch the warning about it being a non-standard config key
assert_true(len(set_config(None, None)) > 10) # tuple of valid keys
with warnings.catch_warnings(record=True) as w: # non-standard key
warnings.simplefilter('always')
set_config(key, None, home_dir=tempdir, set_env=False)
assert_true(len(w) == 1)
assert_true(get_config(key, home_dir=tempdir) is None)
assert_raises(KeyError, get_config, key, raise_error=True)
with warnings.catch_warnings(record=True): # non-standard key
warnings.simplefilter('always')
assert_true(key not in os.environ)
set_config(key, value, home_dir=tempdir, set_env=True)
assert_true(key in os.environ)
assert_true(get_config(key, home_dir=tempdir) == value)
set_config(key, None, home_dir=tempdir, set_env=True)
assert_true(key not in os.environ)
set_config(key, None, home_dir=tempdir, set_env=True)
assert_true(key not in os.environ)
if old_val is not None:
os.environ[key] = old_val
# Check if get_config with key=None returns all config
key = 'MNE_PYTHON_TESTING_KEY'
assert_not_in(key, get_config(home_dir=tempdir))
with warnings.catch_warnings(record=True): # non-standard key
warnings.simplefilter('always')
set_config(key, value, home_dir=tempdir)
assert_equal(get_config(home_dir=tempdir)[key], value)
old_val = os.environ.get(key)
try: # os.environ should take precedence over config file
os.environ[key] = value2
assert_equal(get_config(home_dir=tempdir)[key], value2)
finally: # reset os.environ
if old_val is None:
os.environ.pop(key, None)
else:
os.environ[key] = old_val
# Check what happens when we use a corrupted file
json_fname = get_config_path(home_dir=tempdir)
with open(json_fname, 'w') as fid:
fid.write('foo{}')
with warnings.catch_warnings(record=True) as w:
assert_not_in(key, get_config(home_dir=tempdir))
assert_true(any('not a valid JSON' in str(ww.message) for ww in w))
with warnings.catch_warnings(record=True): # non-standard key
assert_raises(RuntimeError, set_config, key, 'true', home_dir=tempdir)
def test_config():
"""Test mne-python config file support."""
tempdir = _TempDir()
key = '_MNE_PYTHON_CONFIG_TESTING'
value = '123456'
value2 = '123'
old_val = os.getenv(key, None)
os.environ[key] = value
assert_true(get_config(key) == value)
del os.environ[key]
# catch the warning about it being a non-standard config key
assert_true(len(set_config(None, None)) > 10) # tuple of valid keys
with warnings.catch_warnings(record=True) as w: # non-standard key
warnings.simplefilter('always')
set_config(key, None, home_dir=tempdir, set_env=False)
assert_true(len(w) == 1)
assert_true(get_config(key, home_dir=tempdir) is None)
assert_raises(KeyError, get_config, key, raise_error=True)
with warnings.catch_warnings(record=True): # non-standard key
warnings.simplefilter('always')
assert_true(key not in os.environ)
set_config(key, value, home_dir=tempdir, set_env=True)
assert_true(key in os.environ)
assert_true(get_config(key, home_dir=tempdir) == value)
set_config(key, None, home_dir=tempdir, set_env=True)
assert_true(key not in os.environ)
set_config(key, None, home_dir=tempdir, set_env=True)
assert_true(key not in os.environ)
if old_val is not None:
os.environ[key] = old_val
# Check if get_config with key=None returns all config
key = 'MNE_PYTHON_TESTING_KEY'
assert_not_in(key, get_config(home_dir=tempdir))
with warnings.catch_warnings(record=True): # non-standard key
warnings.simplefilter('always')
set_config(key, value, home_dir=tempdir)
assert_equal(get_config(home_dir=tempdir)[key], value)
old_val = os.environ.get(key)
try: # os.environ should take precedence over config file
os.environ[key] = value2
assert_equal(get_config(home_dir=tempdir)[key], value2)
finally: # reset os.environ
if old_val is None:
os.environ.pop(key, None)
else:
os.environ[key] = old_val
# Check what happens when we use a corrupted file
json_fname = get_config_path(home_dir=tempdir)
with open(json_fname, 'w') as fid:
fid.write('foo{}')
with warnings.catch_warnings(record=True) as w:
assert_not_in(key, get_config(home_dir=tempdir))
assert_true(any('not a valid JSON' in str(ww.message) for ww in w))
with warnings.catch_warnings(record=True): # non-standard key
assert_raises(RuntimeError, set_config, key, 'true', home_dir=tempdir)
def test_config():
"""Test mne-python config file support."""
tempdir = _TempDir()
key = '_MNE_PYTHON_CONFIG_TESTING'
value = '123456'
value2 = '123'
old_val = os.getenv(key, None)
os.environ[key] = value
assert (get_config(key) == value)
del os.environ[key]
# catch the warning about it being a non-standard config key
assert (len(set_config(None, None)) > 10) # tuple of valid keys
with pytest.warns(RuntimeWarning, match='non-standard'):
set_config(key, None, home_dir=tempdir, set_env=False)
assert (get_config(key, home_dir=tempdir) is None)
pytest.raises(KeyError, get_config, key, raise_error=True)
assert (key not in os.environ)
with pytest.warns(RuntimeWarning, match='non-standard'):
set_config(key, value, home_dir=tempdir, set_env=True)
assert (key in os.environ)
assert (get_config(key, home_dir=tempdir) == value)
with pytest.warns(RuntimeWarning, match='non-standard'):
set_config(key, None, home_dir=tempdir, set_env=True)
assert (key not in os.environ)
with pytest.warns(RuntimeWarning, match='non-standard'):
set_config(key, None, home_dir=tempdir, set_env=True)
assert (key not in os.environ)
if old_val is not None:
os.environ[key] = old_val
# Check if get_config with key=None returns all config
key = 'MNE_PYTHON_TESTING_KEY'
assert key not in get_config(home_dir=tempdir)
with pytest.warns(RuntimeWarning, match='non-standard'):
set_config(key, value, home_dir=tempdir)
assert_equal(get_config(home_dir=tempdir)[key], value)
old_val = os.environ.get(key)
try: # os.environ should take precedence over config file
os.environ[key] = value2
assert_equal(get_config(home_dir=tempdir)[key], value2)
finally: # reset os.environ
if old_val is None:
os.environ.pop(key, None)
else:
os.environ[key] = old_val
# Check what happens when we use a corrupted file
json_fname = get_config_path(home_dir=tempdir)
with open(json_fname, 'w') as fid:
fid.write('foo{}')
with pytest.warns(RuntimeWarning, match='not a valid JSON'):
assert key not in get_config(home_dir=tempdir)
with pytest.warns(RuntimeWarning, match='non-standard'):
pytest.raises(RuntimeError, set_config, key, 'true', home_dir=tempdir)
def _resize_event(event, params):
"""Function to handle resize event"""
size = ','.join([str(s) for s in params['fig'].get_size_inches()])
set_config('MNE_BROWSE_RAW_SIZE', size, set_env=False)
_layout_figure(params)
================================================
Authors: José C. García Alanis <*****@*****.**>
License: BSD (3-clause)
"""
from mne import open_report
from mne.io import read_raw_fif
from mne.preprocessing import ICA
# All parameters are defined in config.py
from config import fname, parser, n_jobs
# check if NVIDIA CUDA GPU processing should be used
if n_jobs == 'cuda':
from mne.utils import set_config
set_config('MNE_USE_CUDA', 'true')
# Handle command line arguments
args = parser.parse_args()
subject = args.subject
print('Fitting ICA for subject %s' % subject)
###############################################################################
# 1) Import the output from previous processing step
input_file = fname.output(processing_step='repair_bads',
subject=subject,
file_type='raw.fif')
raw = read_raw_fif(input_file, preload=True)
# filter data to remove drifts
