def test_broken_link():
"""
CommandLine:
python -m ubelt.tests.test_links test_broken_link
"""
dpath = ub.ensure_app_cache_dir('ubelt', 'test_broken_link')
ub.delete(dpath, verbose=2)
ub.ensuredir(dpath, verbose=2)
util_links._dirstats(dpath)
broken_fpath = join(dpath, 'broken_fpath.txt')
broken_flink = join(dpath, 'broken_flink.txt')
ub.touch(broken_fpath, verbose=2)
util_links._dirstats(dpath)
ub.symlink(broken_fpath, broken_flink, verbose=2)
util_links._dirstats(dpath)
ub.delete(broken_fpath, verbose=2)
util_links._dirstats(dpath)
# make sure I am sane that this is the correct check.
can_symlink = util_links._can_symlink()
print('can_symlink = {!r}'.format(can_symlink))
if can_symlink:
# normal behavior
assert islink(broken_flink)
assert not exists(broken_flink)
else:
# on windows hard links are essentially the same file.
# there is no trace that it was actually a link.
assert exists(broken_flink)
def test_cant_overwrite_file_with_symlink():
if ub.WIN32:
# Can't distinguish this case on windows
pytest.skip()
dpath = ub.ensure_app_cache_dir('ubelt',
'test_cant_overwrite_file_with_symlink')
ub.delete(dpath, verbose=2)
ub.ensuredir(dpath, verbose=2)
happy_fpath = join(dpath, 'happy_fpath.txt')
happy_flink = join(dpath, 'happy_flink.txt')
for verbose in [2, 1, 0]:
print('=======')
print('verbose = {!r}'.format(verbose))
ub.delete(dpath, verbose=verbose)
ub.ensuredir(dpath, verbose=verbose)
ub.touch(happy_fpath, verbose=verbose)
ub.touch(happy_flink) # create a file where a link should be
util_links._dirstats(dpath)
with pytest.raises(FileExistsError): # file exists error
ub.symlink(happy_fpath,
happy_flink,
overwrite=False,
verbose=verbose)
with pytest.raises(FileExistsError): # file exists error
ub.symlink(happy_fpath,
happy_flink,
overwrite=True,
verbose=verbose)
def test_modname_to_modpath_single():
with ub.TempDir() as temp:
dpath = temp.dpath
# Single module
single = ub.touch(join(dpath, '_tmpsingle.py'))
single_main = ub.touch(join(dpath, '__main__.py'))
with PythonPathContext(dpath):
assert single == _static_modname_to_modpath('_tmpsingle')
assert single == _static_modname_to_modpath('_tmpsingle',
hide_init=True,
hide_main=False)
assert single == _static_modname_to_modpath('_tmpsingle',
hide_init=False,
hide_main=False)
assert single == _static_modname_to_modpath('_tmpsingle',
hide_init=False,
hide_main=True)
# Weird module named main not in a package
assert _static_modname_to_modpath('__main__') == single_main
assert _static_modname_to_modpath('__main__',
hide_init=True,
hide_main=False) == single_main
assert _static_modname_to_modpath('__main__',
hide_init=False,
hide_main=False) == single_main
assert _static_modname_to_modpath('__main__',
hide_init=False,
hide_main=True) == single_main
def test_overwrite_symlink():
"""
CommandLine:
python ~/code/ubelt/tests/test_links.py test_overwrite_symlink
"""
# TODO: test that we handle broken links
dpath = ub.ensure_app_cache_dir('ubelt', 'test_overwrite_symlink')
ub.delete(dpath, verbose=2)
ub.ensuredir(dpath, verbose=2)
happy_fpath = join(dpath, 'happy_fpath.txt')
other_fpath = join(dpath, 'other_fpath.txt')
happy_flink = join(dpath, 'happy_flink.txt')
for verbose in [2, 1, 0]:
print('@==========@')
print('verbose = {!r}'.format(verbose))
print('[test] Setup')
ub.delete(dpath, verbose=verbose)
ub.ensuredir(dpath, verbose=verbose)
ub.touch(happy_fpath, verbose=verbose)
ub.touch(other_fpath, verbose=verbose)
print('[test] Dirstats dpath')
util_links._dirstats(dpath)
print('[test] Create initial link (to happy)')
ub.symlink(happy_fpath, happy_flink, verbose=verbose)
print('[test] Dirstats dpath')
util_links._dirstats(dpath)
# Creating a duplicate link
print('[test] Create a duplicate link (to happy)')
ub.symlink(happy_fpath, happy_flink, verbose=verbose)
print('[test] Dirstats dpath')
util_links._dirstats(dpath)
print('[test] Create an unauthorized overwrite link (to other)')
with pytest.raises(Exception) as exc_info: # file exists error
ub.symlink(other_fpath, happy_flink, verbose=verbose)
print(' * exc_info = {!r}'.format(exc_info))
print('[test] Create an authorized overwrite link (to other)')
ub.symlink(other_fpath, happy_flink, verbose=verbose, overwrite=True)
print('[test] Dirstats dpath')
ub.delete(other_fpath, verbose=verbose)
print('[test] Create an unauthorized overwrite link (back to happy)')
with pytest.raises(Exception) as exc_info: # file exists error
ub.symlink(happy_fpath, happy_flink, verbose=verbose)
print(' * exc_info = {!r}'.format(exc_info))
print('[test] Create an authorized overwrite link (back to happy)')
ub.symlink(happy_fpath, happy_flink, verbose=verbose, overwrite=True)
def test_touch():
import ubelt as ub
dpath = ub.ensure_app_cache_dir('ubelt')
fpath = join(dpath, 'touch_file')
assert not exists(fpath)
ub.touch(fpath, verbose=True)
assert exists(fpath)
os.unlink(fpath)
def test_modify_directory_symlinks():
dpath = ub.ensure_app_cache_dir('ubelt', 'test_modify_symlinks')
ub.delete(dpath, verbose=2)
ub.ensuredir(dpath, verbose=2)
happy_dpath = join(dpath, 'happy_dpath')
happy_dlink = join(dpath, 'happy_dlink')
ub.ensuredir(happy_dpath, verbose=2)
ub.symlink(happy_dpath, happy_dlink, verbose=2)
# Test file inside directory symlink
file_path1 = join(happy_dpath, 'file.txt')
file_path2 = join(happy_dlink, 'file.txt')
ub.touch(file_path1, verbose=2)
assert exists(file_path1)
assert exists(file_path2)
ub.writeto(file_path1, 'foo')
assert ub.readfrom(file_path1) == 'foo'
assert ub.readfrom(file_path2) == 'foo'
ub.writeto(file_path2, 'bar')
assert ub.readfrom(file_path1) == 'bar'
assert ub.readfrom(file_path2) == 'bar'
ub.delete(file_path2, verbose=2)
assert not exists(file_path1)
assert not exists(file_path2)
# Test directory inside directory symlink
dir_path1 = join(happy_dpath, 'dir')
dir_path2 = join(happy_dlink, 'dir')
ub.ensuredir(dir_path1, verbose=2)
assert exists(dir_path1)
assert exists(dir_path2)
subfile_path1 = join(dir_path1, 'subfile.txt')
subfile_path2 = join(dir_path2, 'subfile.txt')
ub.writeto(subfile_path2, 'foo')
assert ub.readfrom(subfile_path1) == 'foo'
assert ub.readfrom(subfile_path2) == 'foo'
ub.writeto(subfile_path1, 'bar')
assert ub.readfrom(subfile_path1) == 'bar'
assert ub.readfrom(subfile_path2) == 'bar'
ub.delete(dir_path1, verbose=2)
assert not exists(dir_path1)
assert not exists(dir_path2)
def make_simple_dummy_package():
"""
Creates a dummy package structure with or without __init__ files
ANY EXISTING FILES ARE DELETED
"""
# Fresh start
dpath = ub.ensure_app_cache_dir("mkinit/test/simple_demo/")
ub.delete(dpath)
ub.ensuredir(dpath)
rel_paths = {
"root": "mkinit_demo_pkg",
"root_init": "mkinit_demo_pkg/__init__.py",
"submod": "mkinit_demo_pkg/submod.py",
"subpkg": "mkinit_demo_pkg/subpkg",
"subpkg_init": "mkinit_demo_pkg/subpkg/__init__.py",
"nested": "mkinit_demo_pkg/subpkg/nested.py",
}
paths = {key: join(dpath, path) for key, path in rel_paths.items()}
for key, path in paths.items():
if not path.endswith(".py"):
ub.ensuredir(path)
for key, path in paths.items():
if path.endswith(".py"):
ub.touch(path)
with open(paths["submod"], "w") as file:
file.write(
ub.codeblock(
"""
print('SUBMOD SIDE EFFECT')
def submod_func():
print('This is a submod func in {}'.format(__file__))
"""
)
)
with open(paths["nested"], "w") as file:
file.write(
ub.codeblock(
"""
print('NESTED SIDE EFFECT')
def nested_func():
print('This is a nested func in {}'.format(__file__))
"""
)
)
return paths
def test_rel_file_link():
dpath = ub.ensure_app_cache_dir('ubelt', 'test_rel_file_link')
ub.delete(dpath, verbose=2)
ub.ensuredir(dpath, verbose=2)
real_fpath = join(ub.ensuredir((dpath, 'dir1')), 'real')
link_fpath = join(ub.ensuredir((dpath, 'dir2')), 'link')
ub.touch(real_fpath)
orig = os.getcwd()
try:
os.chdir(dpath)
real_path = relpath(real_fpath, dpath)
link_path = relpath(link_fpath, dpath)
link = ub.symlink(real_path, link_path)
import sys
if sys.platform.startswith('win32') and isfile(link):
# Note: if windows hard links the file there is no way we can
# tell that it was a symlink. Just verify it exists.
from ubelt import _win32_links
assert _win32_links._win32_is_hardlinked(real_fpath, link_fpath)
else:
pointed = ub.util_links._readlink(link)
resolved = os.path.realpath(
ub.expandpath(join(dirname(link), pointed)))
assert os.path.realpath(ub.expandpath(real_fpath)) == resolved
except Exception:
util_links._dirstats(dpath)
util_links._dirstats(join(dpath, 'dir1'))
util_links._dirstats(join(dpath, 'dir2'))
print('TEST FAILED: test_rel_link')
print('real_fpath = {!r}'.format(real_fpath))
print('link_fpath = {!r}'.format(link_fpath))
print('real_path = {!r}'.format(real_path))
print('link_path = {!r}'.format(link_path))
try:
if 'link' in vars():
print('link = {!r}'.format(link))
if 'pointed' in vars():
print('pointed = {!r}'.format(pointed))
if 'resolved' in vars():
print('resolved = {!r}'.format(resolved))
except Exception:
print('...rest of the names are not available')
raise
finally:
util_links._dirstats(dpath)
util_links._dirstats(join(dpath, 'dir1'))
util_links._dirstats(join(dpath, 'dir2'))
os.chdir(orig)
def test_modname_to_modpath_namespace():
"""
Ignore:
import sys
sys.path.append('/home/joncrall/code/xdoctest/testing')
from test_static import *
temp = ub.TempDir()
temp.__enter__()
sys.path.append(temp.dpath)
temp.__exit__(None, None, None)
%timeit _syspath_modname_to_modpath('xdoctest.static_analysis')
%timeit _pkgutil_modname_to_modpath('xdoctest.static_analysis')
"""
with ub.TempDir() as temp:
dpath = temp.dpath
# Some "bad" non-module directories
tmpbad = ub.ensuredir((dpath, '_tmpbad'))
# Make a submodule of a bad directory, look good.
sub_bad = ub.ensuredir((tmpbad, 'sub_bad'))
ub.touch(join(tmpbad, '_inbad.py'))
subbad = ub.touch(join(sub_bad, '__init__.py')) # NOQA
b0 = ub.touch(join(sub_bad, 'b0.py')) # NOQA
with PythonPathContext(dpath):
assert _static_modname_to_modpath('_tmpbad') is None
# Tricky case, these modules look good outside of _tmpbad WOW, you
# can actually import this and it works, but pkgloader still
# returns None so we should too.
assert _static_modname_to_modpath('_tmpbad.sub_bad') is None
assert _static_modname_to_modpath('_tmpbad.sub_bad.b0') is None
# We should be able to statically find all of the good module
# directories.
# this should all be static
import sys
assert '_tmpsingle' not in sys.modules
assert '_tmpbad' not in sys.modules
def test_overwrite_symlink():
"""
CommandLine:
python -m ubelt.tests.test_links test_overwrite_symlink
"""
# TODO: test that we handle broken links
dpath = ub.ensure_app_cache_dir('ubelt', 'test_overwrite_symlink')
ub.delete(dpath, verbose=2)
ub.ensuredir(dpath, verbose=2)
happy_fpath = join(dpath, 'happy_fpath.txt')
other_fpath = join(dpath, 'other_fpath.txt')
happy_flink = join(dpath, 'happy_flink.txt')
for verbose in [2, 1, 0]:
print('=======')
print('verbose = {!r}'.format(verbose))
ub.delete(dpath, verbose=verbose)
ub.ensuredir(dpath, verbose=verbose)
ub.touch(happy_fpath, verbose=verbose)
ub.touch(other_fpath, verbose=verbose)
util_links._dirstats(dpath)
ub.symlink(happy_fpath, happy_flink, verbose=verbose)
# Creating a duplicate link
# import six
# import sys
# if not six.PY2 and sys.platform.startswith('win32'):
util_links._dirstats(dpath)
ub.symlink(happy_fpath, happy_flink, verbose=verbose)
util_links._dirstats(dpath)
with pytest.raises(Exception): # file exists error
ub.symlink(other_fpath, happy_flink, verbose=verbose)
ub.symlink(other_fpath, happy_flink, verbose=verbose, overwrite=True)
ub.delete(other_fpath, verbose=verbose)
with pytest.raises(Exception): # file exists error
ub.symlink(happy_fpath, happy_flink, verbose=verbose)
ub.symlink(happy_fpath, happy_flink, verbose=verbose, overwrite=True)
def test_modify_file_symlinks():
"""
CommandLine:
python -m ubelt.tests.test_links test_modify_symlinks
"""
# TODO: test that we handle broken links
dpath = ub.ensure_app_cache_dir('ubelt', 'test_modify_symlinks')
happy_fpath = join(dpath, 'happy_fpath.txt')
happy_flink = join(dpath, 'happy_flink.txt')
ub.touch(happy_fpath, verbose=2)
ub.symlink(happy_fpath, happy_flink, verbose=2)
# Test file symlink
ub.writeto(happy_fpath, 'foo')
assert ub.readfrom(happy_fpath) == 'foo'
assert ub.readfrom(happy_flink) == 'foo'
ub.writeto(happy_flink, 'bar')
assert ub.readfrom(happy_fpath) == 'bar'
assert ub.readfrom(happy_flink) == 'bar'
def test_import_modpath_package():
assert '_tmproot373.sub1.sub2.testmod' not in sys.modules
temp = ub.TempDir().start()
# with ub.TempDir() as temp:
if True:
dpath = temp.dpath
# Create a dummy package heirachy
root = ub.ensuredir((dpath, '_tmproot373'))
sub1 = ub.ensuredir((root, 'sub1'))
sub2 = ub.ensuredir((sub1, 'sub2'))
ub.touch(join(root, '__init__.py'))
ub.touch(join(sub1, '__init__.py'))
ub.touch(join(sub2, '__init__.py'))
modpath = join(sub2, 'testmod.py')
text = ub.codeblock(
'''
a = 'value'
''')
ub.writeto(modpath, text)
assert temp.dpath not in sys.path
module = ub.import_module_from_path(modpath)
assert temp.dpath not in sys.path, 'pythonpath should remain clean'
assert module.a == 'value'
assert module.__file__ == modpath
assert module.__name__ == '_tmproot373.sub1.sub2.testmod'
assert '_tmproot373.sub1.sub2.testmod' in sys.modules
assert '_tmproot373.sub1.sub2' in sys.modules
assert '_tmproot373' in sys.modules
def test_globstr_with_nargs():
from os.path import join
import ubelt as ub
import scriptconfig as scfg
dpath = ub.ensure_app_cache_dir('scriptconfig/tests/files')
ub.touch(join(dpath, 'file1.txt'))
ub.touch(join(dpath, 'file2.txt'))
ub.touch(join(dpath, 'file3.txt'))
class TestConfig(scfg.Config):
default = {
'paths': scfg.Value(None, nargs='+'),
}
cmdline = '--paths {dpath}/*'.format(dpath=dpath)
config = TestConfig(cmdline=cmdline)
# ub.cmd(f'echo {dpath}/*', shell=True)
import glob
cmdline = '--paths ' + ' '.join(list(glob.glob(join(dpath, '*'))))
config = TestConfig(cmdline=cmdline)
cmdline = '--paths=' + ','.join(list(glob.glob(join(dpath, '*'))))
config = TestConfig(cmdline=cmdline)
def test_modname_to_modpath_package():
"""
CommandLine:
pytest testing/test_static.py::test_modname_to_modpath_package
Ignore:
import sys
sys.path.append('/home/joncrall/code/xdoctest/testing')
from test_static import *
temp = ub.TempDir()
temp.__enter__()
sys.path.append(temp.dpath)
temp.__exit__(None, None, None)
"""
with ub.TempDir() as temp:
dpath = temp.dpath
# Create a dummy package heirachy
root = ub.ensuredir((dpath, '_tmproot927'))
sub1 = ub.ensuredir((root, 'sub1'))
sub2 = ub.ensuredir((sub1, 'sub2'))
root_init = ub.touch(join(root, '__init__.py'))
sub1_init = ub.touch(join(sub1, '__init__.py'))
sub2_init = ub.touch(join(sub2, '__init__.py'))
mod0 = ub.touch(join(root, 'mod0.py'))
mod1 = ub.touch(join(sub1, 'mod1.py'))
mod2 = ub.touch(join(sub2, 'mod2.py'))
root_main = ub.touch(join(root, '__main__.py'))
sub2_main = ub.touch(join(sub2, '__main__.py'))
bad1 = ub.ensuredir((root, 'bad1'))
bad2 = ub.ensuredir((sub1, 'bad2'))
ub.touch(join(bad1, 'b0.py'))
ub.touch(join(bad2, 'b0.py'))
with PythonPathContext(dpath):
# Bad module directories should return None
assert _static_modname_to_modpath('_tmproot927.bad1') is None
assert _static_modname_to_modpath('_tmproot927.sub1.bad1') is None
assert _static_modname_to_modpath('_tmproot927.bad1.b0') is None
assert _static_modname_to_modpath('_tmproot927.sub1.bad1.b1') is None
assert _static_modname_to_modpath('_tmproot927.bad1') is None
# package modules are accessable by the full path
assert root == _static_modname_to_modpath('_tmproot927')
assert sub1 == _static_modname_to_modpath('_tmproot927.sub1')
assert sub2 == _static_modname_to_modpath('_tmproot927.sub1.sub2')
assert mod0 == _static_modname_to_modpath('_tmproot927.mod0')
assert mod1 == _static_modname_to_modpath('_tmproot927.sub1.mod1')
assert mod2 == _static_modname_to_modpath('_tmproot927.sub1.sub2.mod2')
# specifying a suffix will not work
assert _static_modname_to_modpath('sub1') is None
assert _static_modname_to_modpath('sub1.sub2') is None
assert _static_modname_to_modpath('mod0') is None
assert _static_modname_to_modpath('sub1.mod1') is None
assert _static_modname_to_modpath('sub1.sub2.mod2') is None
# Specify init if available
assert root_init == _static_modname_to_modpath('_tmproot927', hide_init=False)
if 1:
# Test init
assert _static_modname_to_modpath('_tmproot927', hide_init=False) == root_init
assert _static_modname_to_modpath('_tmproot927.__init__', hide_init=False) == root_init
assert _static_modname_to_modpath('_tmproot927.__main__', hide_init=False, hide_main=True) == root
# Test main
assert _static_modname_to_modpath('_tmproot927', hide_main=False) == root
assert _static_modname_to_modpath('_tmproot927.__init__', hide_main=False) == root
assert _static_modname_to_modpath('_tmproot927.__main__', hide_main=False) == root_main
# Test init and main both false
assert _static_modname_to_modpath('_tmproot927.__init__') == root
assert _static_modname_to_modpath('_tmproot927.__main__', hide_main=True) == root
# Test init and main both true
assert _static_modname_to_modpath('_tmproot927', hide_init=False, hide_main=False) == root_init
assert _static_modname_to_modpath('_tmproot927.__init__', hide_init=False, hide_main=False) == root_init
assert _static_modname_to_modpath('_tmproot927.__main__', hide_init=False, hide_main=False) == root_main
if 2:
# Test in a nested directory
# Test init
assert _static_modname_to_modpath('_tmproot927.sub1.sub2', hide_init=False) == sub2_init
assert _static_modname_to_modpath('_tmproot927.sub1.sub2.__init__', hide_init=False) == sub2_init
assert _static_modname_to_modpath('_tmproot927.sub1.sub2.__main__', hide_init=False, hide_main=True) == sub2
# Test main
assert _static_modname_to_modpath('_tmproot927.sub1.sub2', hide_main=False) == sub2
assert _static_modname_to_modpath('_tmproot927.sub1.sub2.__main__', hide_main=False) == sub2_main
assert _static_modname_to_modpath('_tmproot927.sub1.sub2.__init__', hide_main=False) == sub2
# Test init and main both false
assert _static_modname_to_modpath('_tmproot927.sub1.sub2.__init__', hide_main=True) == sub2
assert _static_modname_to_modpath('_tmproot927.sub1.sub2.__main__', hide_main=True) == sub2
# Test init and main both true
assert _static_modname_to_modpath('_tmproot927.sub1.sub2', hide_init=False, hide_main=False) == sub2_init
assert _static_modname_to_modpath('_tmproot927.sub1.sub2.__init__', hide_init=False, hide_main=False) == sub2_init
assert _static_modname_to_modpath('_tmproot927.sub1.sub2.__main__', hide_init=False, hide_main=False) == sub2_main
if 3:
# Test in a nested directory with __init__ but no __main__
# Test init
assert _static_modname_to_modpath('_tmproot927.sub1', hide_init=False) == sub1_init
assert _static_modname_to_modpath('_tmproot927.sub1.__init__', hide_init=False) == sub1_init
assert _static_modname_to_modpath('_tmproot927.sub1.__main__', hide_init=False) is None
# Test main
assert _static_modname_to_modpath('_tmproot927.sub1', hide_main=False) == sub1
assert _static_modname_to_modpath('_tmproot927.sub1.__main__', hide_main=False) is None
assert _static_modname_to_modpath('_tmproot927.sub1.__init__', hide_main=False) == sub1
# Test init and main both false
assert _static_modname_to_modpath('_tmproot927.sub1.__init__') == sub1
assert _static_modname_to_modpath('_tmproot927.sub1.__main__') is None
# Test init and main both true
assert _static_modname_to_modpath('_tmproot927.sub1', hide_init=False, hide_main=False) == sub1_init
assert _static_modname_to_modpath('_tmproot927.sub1.__init__', hide_init=False, hide_main=False) == sub1_init
assert _static_modname_to_modpath('_tmproot927.sub1.__main__', hide_init=False, hide_main=False) is None
assert '_tmproot927' not in sys.modules
assert '_tmproot927.mod0' not in sys.modules
assert '_tmproot927.sub1' not in sys.modules
assert '_tmproot927.sub1.mod1' not in sys.modules
assert '_tmproot927.sub1.sub2' not in sys.modules
assert '_tmproot927.sub1.mod2.mod2' not in sys.modules
def make_dummy_package(dpath, pkgname='mkinit_dummy_module'):
"""
Creates a dummy package structure with or without __init__ files
"""
root = ub.ensuredir(join(dpath, pkgname))
ub.delete(root)
ub.ensuredir(root)
paths = {
'root': root,
'submod1': ub.touch(join(root, 'submod1.py')),
'submod2': ub.touch(join(root, 'submod2.py')),
'subdir1': ub.ensuredir(join(root, 'subdir1')),
'subdir2': ub.ensuredir(join(root, 'subdir2')),
}
paths['subdir1_init'] = ub.touch(join(paths['subdir1'], '__init__.py'))
paths['subdir2_init'] = ub.touch(join(paths['subdir2'], '__init__.py'))
paths['root_init'] = ub.touch(join(paths['root'], '__init__.py'))
ub.writeto(paths['subdir1_init'], ub.codeblock(
'''
simple_subattr1 = "hello world"
simple_subattr2 = "hello world"
_private_attr = "hello world"
'''))
ub.writeto(paths['subdir2_init'], ub.codeblock(
'''
__all__ = ['public_attr']
public_attr = "hello world"
private_attr = "hello world"
'''))
ub.writeto(paths['submod1'], ub.codeblock(
'''
import six
attr1 = True
attr2 = six.moves.zip
# ------------------------
if True:
good_attr_01 = None
if False:
bad_attr_false1 = None
if None:
bad_attr_none1 = None
# ------------------------
if True:
good_attr_02 = None
else:
bad_attr_true2 = None
if False:
bad_attr_false2 = None
else:
good_attr_03 = None
if None:
bad_attr_none2 = None
else:
good_attr_04 = None
# ------------------------
if True:
good_attr_05 = None
elif False:
bad_attr3 = None
else:
bad_attr3 = None
if False:
bad_attr_elif_True3_0 = None
elif True:
good_attr_06 = None
else:
bad_attr_elif_True3_1 = None
# ------------------------
import sys
if sys.version_info.major == 3:
good_attr_07 = 'py3'
bad_attr_uncommon4_1 = None
else:
good_attr_07 = 'py2'
bad_attr_uncommon4_0 = None
# ------------------------
# This is static, so maybe another_val exists as a global
if sys.version_info.major == good_attr_07:
good_attr_08 = None
bad_attr_uncommon5_1 = None
bad_attr_uncommon5_0 = None
elif sys:
good_attr_08 = None
bad_attr_uncommon5_1 = None
else:
good_attr_08 = None
bad_attr_uncommon5_0 = None
# ------------------------
flag1 = sys.version_info.major < 10
flag2 = sys.version_info.major > 10
flag3 = sys.version_info.major > 10
if flag1:
bad_attr_num6 = 1
elif flag2:
bad_attr_num6 = 1
elif flag3:
bad_attr_num6 = 1
if flag1:
bad_attr_num6_0 = 1
elif 0:
bad_attr_num0 = 1
elif 1:
bad_attr_09 = 1
else:
bad_attr13 = 1
if flag1:
good_attr_09 = 1
elif 1:
good_attr_09 = 1
bad_attr_09_1 = 1
elif 2 == 3:
pass
# ------------------------
if 'foobar':
good_attr_10 = 1
if False:
bad_attr_str7 = 1
elif (1, 2):
good_attr_11 = 1
elif True:
bad_attr_true8 = 1
# ------------------------
if flag1 != flag2:
good_attr_12 = None
else:
bad_attr_12 = None
raise Exception
# ------------------------
try:
good_attr_13 = None
bad_attr_13 = None
except Exception:
good_attr_13 = None
# ------------------------
try:
good_attr_14 = None
except Exception:
bad_attr_14 = None
raise
# ------------------------
def func1():
pass
class class1():
pass
if __name__ == '__main__':
bad_attr_main = None
if __name__ == 'something_else':
bad_something_else = None
'''))
return paths
def test_callbacks(ActorClass, F=0.01):
"""
F is a Factor to control wait time
CommandLine:
python -m futures_actors.tests test_callbacks:1
Example:
>>> from futures_actors.tests import * # NOQA
>>> try:
>>> test_callbacks(TestProcessActor, F=0.1)
>>> except AssertionError as ex:
>>> # If it fails once on the fast setting try
>>> # once more on a slower setting (for travis python 2.7)
>>> print(ex)
>>> print('Failed the fast version. Try once more, but slower')
>>> test_callbacks(TestProcessActor, F=2.0)
Example:
>>> from futures_actors.tests import * # NOQA
>>> try:
>>> test_callbacks(TestThreadActor, F=0.1)
>>> except AssertionError as ex:
>>> print(ex)
>>> # If it fails once on the fast setting try
>>> # once more on a slower setting (for travis python 2.7)
>>> print('Failed the fast version. Try once more, but slower')
>>> test_callbacks(TestThreadActor, F=2.0)
"""
print('Test callbacks for {}'.format(ActorClass))
import shutil
print('Test cancel for {}'.format(ActorClass))
test_state = {'num': 0}
def done_callback(f):
num = f.result()
test_state['num'] += num
print('DONE CALLBACK GOT = {}'.format(num))
cache_dpath = ub.ensure_app_cache_dir('futures_actors', 'tests')
shutil.rmtree(cache_dpath)
ub.ensuredir(cache_dpath)
fpaths = [join(cache_dpath, 'lock{}'.format(i)) for i in range(0, 5)]
executor = ActorClass.executor()
try:
print('Submit task 1')
f1 = executor.post({'action': 'lockfile', 'num': 1, 'fpath': fpaths[1]})
f1.add_done_callback(done_callback)
print('Submit task 2')
f2 = executor.post({'action': 'lockfile', 'num': 2, 'fpath': fpaths[2]})
f2.add_done_callback(done_callback)
print('Submit task 3')
f3 = executor.post({'action': 'lockfile', 'num': 3, 'fpath': fpaths[3]})
f3.add_done_callback(done_callback)
# Should reach this immediately before any task is done
num = test_state['num']
assert num == 0, 'should not have finished any task yet. got num={}'.format(num)
# Unblock task2, but task1 should still be blocking it
print('unblock task2')
ub.touch(fpaths[2])
import time
time.sleep(.01)
num = test_state['num']
assert num == 0, 'should be blocked by task1. got num={}'.format(num)
# Unblock task1
print('unblock task1')
ub.touch(fpaths[1])
# Wait for the second result
print(f2.result())
assert f1.done(), 'first task should be done'
num = test_state['num']
assert num == 3, 'should have finished task 1 and 2. got num={}'.format(num)
# Wait for the third result
print('unblock task3')
ub.touch(fpaths[3])
print(f3.result())
num = test_state['num']
assert num == 6, 'should have finished 3 tasks. got num={}'.format(num)
finally:
print('shutdown executor')
executor.shutdown(wait=False)
shutil.rmtree(cache_dpath)
def test_package_submodules():
"""
CommandLine:
pytest testing/test_static.py::test_package_submodules -s
xdoctest -m ~/code/ubelt/tests/test_import.py test_package_submodules
pass
Ignore:
import sys
sys.path.append('/home/joncrall/code/xdoctest/testing')
from test_static import *
temp = ub.TempDir()
temp.__enter__()
sys.path.append(temp.dpath)
temp.__exit__(None, None, None)
"""
from xdoctest import static_analysis as static
with ub.TempDir() as temp:
dpath = temp.dpath
# Create a dummy package heirachy
root = ub.ensuredir((dpath, '_tmproot927'))
sub1 = ub.ensuredir((root, 'sub1'))
sub2 = ub.ensuredir((sub1, 'sub2'))
root_init = ub.touch(join(root, '__init__.py'))
sub1_init = ub.touch(join(sub1, '__init__.py'))
sub2_init = ub.touch(join(sub2, '__init__.py'))
mod0 = ub.touch(join(root, 'mod0.py'))
mod1 = ub.touch(join(sub1, 'mod1.py'))
mod2 = ub.touch(join(sub2, 'mod2.py'))
root_main = ub.touch(join(root, '__main__.py'))
sub2_main = ub.touch(join(sub2, '__main__.py'))
bad1 = ub.ensuredir((root, 'bad1'))
bad2 = ub.ensuredir((sub1, 'bad2'))
b0 = ub.touch(join(bad1, 'b0.py'))
b1 = ub.touch(join(bad2, 'b1.py'))
with PythonPathContext(dpath):
subpaths = sorted(static.package_modpaths(root, with_pkg=True))
# should only return files not directories
assert root_init in subpaths
assert sub1_init in subpaths
assert sub2_init in subpaths
assert root not in subpaths
assert sub1 not in subpaths
assert sub2 not in subpaths
assert root_main in subpaths
assert sub2_main in subpaths
assert mod0 in subpaths
assert mod1 in subpaths
assert mod2 in subpaths
assert bad1 not in subpaths
assert b0 not in subpaths
assert b1 not in subpaths
assert '_tmproot927' not in sys.modules
assert '_tmproot927.mod0' not in sys.modules
assert '_tmproot927.sub1' not in sys.modules
assert '_tmproot927.sub1.mod1' not in sys.modules
assert '_tmproot927.sub1.sub2' not in sys.modules
assert '_tmproot927.sub1.mod2.mod2' not in sys.modules
def test_modpath_to_modname():
"""
CommandLine:
pytest testing/test_static.py::test_modpath_to_modname -s
python testing/test_static.py test_modpath_to_modname
"""
with ub.TempDir() as temp:
dpath = temp.dpath
# Create a dummy package heirachy
root = ub.ensuredir((dpath, '_tmproot927'))
sub1 = ub.ensuredir((root, 'sub1'))
sub2 = ub.ensuredir((sub1, 'sub2'))
root_init = ub.touch(join(root, '__init__.py'))
sub1_init = ub.touch(join(sub1, '__init__.py'))
sub2_init = ub.touch(join(sub2, '__init__.py'))
mod0 = ub.touch(join(root, 'mod0.py'))
mod1 = ub.touch(join(sub1, 'mod1.py'))
mod2 = ub.touch(join(sub2, 'mod2.py'))
root_main = ub.touch(join(root, '__main__.py'))
sub2_main = ub.touch(join(sub2, '__main__.py'))
bad1 = ub.ensuredir((root, 'bad1'))
bad2 = ub.ensuredir((sub1, 'bad2'))
b0 = ub.touch(join(bad1, 'b0.py'))
b1 = ub.touch(join(bad2, 'b1.py'))
import os
ub.modpath_to_modname(root, relativeto=os.path.dirname(dpath)) # TODO: assert correct output
with PythonPathContext(dpath):
assert ub.modpath_to_modname(root) == '_tmproot927'
assert ub.modpath_to_modname(sub1) == '_tmproot927.sub1'
assert ub.modpath_to_modname(sub2) == '_tmproot927.sub1.sub2'
assert ub.modpath_to_modname(mod0) == '_tmproot927.mod0'
assert ub.modpath_to_modname(mod1) == '_tmproot927.sub1.mod1'
assert ub.modpath_to_modname(mod2) == '_tmproot927.sub1.sub2.mod2'
assert ub.modpath_to_modname(root_init) == '_tmproot927'
assert ub.modpath_to_modname(sub1_init) == '_tmproot927.sub1'
assert ub.modpath_to_modname(sub2_init) == '_tmproot927.sub1.sub2'
assert ub.modpath_to_modname(root_init, hide_init=False) == '_tmproot927.__init__'
assert ub.modpath_to_modname(sub1_init, hide_init=False) == '_tmproot927.sub1.__init__'
assert ub.modpath_to_modname(sub2_init, hide_init=False) == '_tmproot927.sub1.sub2.__init__'
assert ub.modpath_to_modname(root, hide_main=True, hide_init=False) == '_tmproot927.__init__'
assert ub.modpath_to_modname(sub1, hide_main=True, hide_init=False) == '_tmproot927.sub1.__init__'
assert ub.modpath_to_modname(sub2, hide_main=True, hide_init=False) == '_tmproot927.sub1.sub2.__init__'
assert ub.modpath_to_modname(root, hide_main=False, hide_init=False) == '_tmproot927.__init__'
assert ub.modpath_to_modname(sub1, hide_main=False, hide_init=False) == '_tmproot927.sub1.__init__'
assert ub.modpath_to_modname(sub2, hide_main=False, hide_init=False) == '_tmproot927.sub1.sub2.__init__'
assert ub.modpath_to_modname(root, hide_main=False, hide_init=True) == '_tmproot927'
assert ub.modpath_to_modname(sub1, hide_main=False, hide_init=True) == '_tmproot927.sub1'
assert ub.modpath_to_modname(sub2, hide_main=False, hide_init=True) == '_tmproot927.sub1.sub2'
assert ub.modpath_to_modname(root_main, hide_main=False, hide_init=True) == '_tmproot927.__main__'
assert ub.modpath_to_modname(sub2_main, hide_main=False, hide_init=True) == '_tmproot927.sub1.sub2.__main__'
assert ub.modpath_to_modname(root_main, hide_main=False, hide_init=True) == '_tmproot927.__main__'
assert ub.modpath_to_modname(sub2_main, hide_main=False, hide_init=True) == '_tmproot927.sub1.sub2.__main__'
assert ub.modpath_to_modname(root_main, hide_main=True, hide_init=True) == '_tmproot927'
assert ub.modpath_to_modname(sub2_main, hide_main=True, hide_init=True) == '_tmproot927.sub1.sub2'
assert ub.modpath_to_modname(root_main, hide_main=True, hide_init=False) == '_tmproot927'
assert ub.modpath_to_modname(sub2_main, hide_main=True, hide_init=False) == '_tmproot927.sub1.sub2'
# Non-existant / invalid modules should always be None
for a, b in it.product([True, False], [True, False]):
with pytest.raises(ValueError):
ub.modpath_to_modname(join(sub1, '__main__.py'), hide_main=a, hide_init=b)
assert ub.modpath_to_modname(b0, hide_main=a, hide_init=b) == 'b0'
assert ub.modpath_to_modname(b1, hide_main=a, hide_init=b) == 'b1'
with pytest.raises(ValueError):
ub.modpath_to_modname(bad1, hide_main=a, hide_init=b)
with pytest.raises(ValueError):
ub.modpath_to_modname(bad2, hide_main=a, hide_init=b)
assert '_tmproot927' not in sys.modules
assert '_tmproot927.mod0' not in sys.modules
assert '_tmproot927.sub1' not in sys.modules
assert '_tmproot927.sub1.mod1' not in sys.modules
assert '_tmproot927.sub1.sub2' not in sys.modules
assert '_tmproot927.sub1.mod2.mod2' not in sys.modules
def test_delete_symlinks():
"""
CommandLine:
python -m ubelt.tests.test_links test_delete_symlinks
"""
# TODO: test that we handle broken links
dpath = ub.ensure_app_cache_dir('ubelt', 'test_delete_links')
happy_dpath = join(dpath, 'happy_dpath')
happy_dlink = join(dpath, 'happy_dlink')
happy_fpath = join(dpath, 'happy_fpath.txt')
happy_flink = join(dpath, 'happy_flink.txt')
broken_dpath = join(dpath, 'broken_dpath')
broken_dlink = join(dpath, 'broken_dlink')
broken_fpath = join(dpath, 'broken_fpath.txt')
broken_flink = join(dpath, 'broken_flink.txt')
def check_path_condition(path, positive, want, msg):
if not want:
positive = not positive
msg = 'not ' + msg
if not positive:
util_links._dirstats(dpath)
print('About to raise error: {}'.format(msg))
print('path = {!r}'.format(path))
print('exists(path) = {!r}'.format(exists(path)))
print('islink(path) = {!r}'.format(islink(path)))
print('isdir(path) = {!r}'.format(isdir(path)))
print('isfile(path) = {!r}'.format(isfile(path)))
raise AssertionError('path={} {}'.format(path, msg))
def assert_sometrace(path, want=True):
# Either exists or is a broken link
positive = exists(path) or islink(path)
check_path_condition(path, positive, want, 'has trace')
def assert_broken_link(path, want=True):
if util_links._can_symlink():
print('path={} should{} be a broken link'.format(
path, ' ' if want else ' not'))
positive = not exists(path) and islink(path)
check_path_condition(path, positive, want, 'broken link')
else:
# TODO: we can test this
# positive = util_links._win32_is_junction(path)
print('path={} should{} be a broken link (junction)'.format(
path, ' ' if want else ' not'))
print('cannot check this yet')
# We wont be able to differentiate links and nonlinks for junctions
# positive = exists(path)
# check_path_condition(path, positive, want, 'broken link')
util_links._dirstats(dpath)
ub.delete(dpath, verbose=2)
ub.ensuredir(dpath, verbose=2)
util_links._dirstats(dpath)
ub.ensuredir(happy_dpath, verbose=2)
ub.ensuredir(broken_dpath, verbose=2)
ub.touch(happy_fpath, verbose=2)
ub.touch(broken_fpath, verbose=2)
util_links._dirstats(dpath)
ub.symlink(broken_fpath, broken_flink, verbose=2)
ub.symlink(broken_dpath, broken_dlink, verbose=2)
ub.symlink(happy_fpath, happy_flink, verbose=2)
ub.symlink(happy_dpath, happy_dlink, verbose=2)
util_links._dirstats(dpath)
# Deleting the files should not delete the symlinks (windows)
ub.delete(broken_fpath, verbose=2)
util_links._dirstats(dpath)
ub.delete(broken_dpath, verbose=2)
util_links._dirstats(dpath)
assert_broken_link(broken_flink, 1)
assert_broken_link(broken_dlink, 1)
assert_sometrace(broken_fpath, 0)
assert_sometrace(broken_dpath, 0)
assert_broken_link(happy_flink, 0)
assert_broken_link(happy_dlink, 0)
assert_sometrace(happy_fpath, 1)
assert_sometrace(happy_dpath, 1)
# broken symlinks no longer exist after they are deleted
ub.delete(broken_dlink, verbose=2)
util_links._dirstats(dpath)
assert_sometrace(broken_dlink, 0)
ub.delete(broken_flink, verbose=2)
util_links._dirstats(dpath)
assert_sometrace(broken_flink, 0)
# real symlinks no longer exist after they are deleted
# but the original data is fine
ub.delete(happy_dlink, verbose=2)
util_links._dirstats(dpath)
assert_sometrace(happy_dlink, 0)
assert_sometrace(happy_dpath, 1)
ub.delete(happy_flink, verbose=2)
util_links._dirstats(dpath)
assert_sometrace(happy_flink, 0)
assert_sometrace(happy_fpath, 1)
def make_dummy_package(dpath, pkgname="mkinit_dummy_module", side_effects=0):
"""
Creates a dummy package structure with or without __init__ files
ANY EXISTING FILES ARE DELETED
"""
root = ub.ensuredir(join(dpath, pkgname))
ub.delete(root)
ub.ensuredir(root)
paths = {
"root":
root,
"submod1":
ub.touch(join(root, "submod1.py")),
"submod2":
ub.touch(join(root, "submod2.py")),
"subdir1":
ub.ensuredir(join(root, "subdir1")),
"subdir2":
ub.ensuredir(join(root, "subdir2")),
"longsubdir":
ub.ensuredir(join(root, "avery/long/subdir/that/goes/over80chars")),
}
paths["subdir1_init"] = ub.touch(join(paths["subdir1"], "__init__.py"))
paths["subdir2_init"] = ub.touch(join(paths["subdir2"], "__init__.py"))
paths["root_init"] = ub.touch(join(paths["root"], "__init__.py"))
paths["long_subdir_init"] = ub.touch(
join(paths["longsubdir"], "__init__.py"))
paths["long_submod"] = ub.touch(join(paths["longsubdir"],
"long_submod.py"))
ub.writeto(
paths["subdir1_init"],
ub.codeblock("""
simple_subattr1 = "hello world"
simple_subattr2 = "hello world"
_private_attr = "hello world"
"""),
)
ub.writeto(
paths["subdir2_init"],
ub.codeblock("""
__all__ = ['public_attr']
public_attr = "hello world"
private_attr = "hello world"
"""),
)
ub.writeto(
paths["submod1"],
ub.codeblock("""
import six
attr1 = True
attr2 = six.moves.zip
# ------------------------
if True:
good_attr_01 = None
if False:
bad_attr_false1 = None
if None:
bad_attr_none1 = None
# ------------------------
if True:
good_attr_02 = None
else:
bad_attr_true2 = None
if False:
bad_attr_false2 = None
else:
good_attr_03 = None
if None:
bad_attr_none2 = None
else:
good_attr_04 = None
# ------------------------
if True:
good_attr_05 = None
elif False:
bad_attr3 = None
else:
bad_attr3 = None
if False:
bad_attr_elif_True3_0 = None
elif True:
good_attr_06 = None
else:
bad_attr_elif_True3_1 = None
# ------------------------
import sys
if sys.version_info.major == 3:
good_attr_07 = 'py3'
bad_attr_uncommon4_1 = None
else:
good_attr_07 = 'py2'
bad_attr_uncommon4_0 = None
# ------------------------
# This is static, so maybe another_val exists as a global
if sys.version_info.major == good_attr_07:
good_attr_08 = None
bad_attr_uncommon5_1 = None
bad_attr_uncommon5_0 = None
elif sys:
good_attr_08 = None
bad_attr_uncommon5_1 = None
else:
good_attr_08 = None
bad_attr_uncommon5_0 = None
# ------------------------
flag1 = sys.version_info.major < 10
flag2 = sys.version_info.major > 10
flag3 = sys.version_info.major > 10
if flag1:
bad_attr_num6 = 1
elif flag2:
bad_attr_num6 = 1
elif flag3:
bad_attr_num6 = 1
if flag1:
bad_attr_num6_0 = 1
elif 0:
bad_attr_num0 = 1
elif 1:
bad_attr_09 = 1
else:
bad_attr13 = 1
if flag1:
good_attr_09 = 1
elif 1:
good_attr_09 = 1
bad_attr_09_1 = 1
elif 2 == 3:
pass
# ------------------------
if 'foobar':
good_attr_10 = 1
if False:
bad_attr_str7 = 1
elif (1, 2):
good_attr_11 = 1
elif True:
bad_attr_true8 = 1
# ------------------------
if flag1 != flag2:
good_attr_12 = None
else:
bad_attr_12 = None
raise Exception
# ------------------------
try:
good_attr_13 = None
bad_attr_13 = None
except Exception:
good_attr_13 = None
# ------------------------
try:
good_attr_14 = None
except Exception:
bad_attr_14 = None
raise
# ------------------------
def func1():
pass
class class1():
pass
if __name__ == '__main__':
bad_attr_main = None
if __name__ == 'something_else':
bad_something_else = None
"""),
)
# Ensure that each submodule has an __init__
# (do we need this with PEP 420 anymore?)
root = paths["root"]
from os.path import relpath, exists, dirname
import os
dpath = dirname(root)
init_fpaths = set()
for key, path in paths.items():
relative = relpath(path, dpath)
suffix = []
parts = relative.split(os.sep)
for part in parts:
if "." not in part:
suffix.append(part)
middir = join(dpath, os.sep.join(suffix))
fpath = join(middir, "__init__.py")
init_fpaths.add(fpath)
for fpath in init_fpaths:
if not exists(fpath):
ub.touch(fpath)
ub.writeto(
paths["long_submod"],
ub.codeblock("""
def a_very_nested_function():
print('a_very_nested_function in {}'.format(__file__))
def another_func1():
pass
def another_func2():
pass
def another_func3():
pass
def another_func4():
pass
"""),
)
if side_effects:
with open(paths["long_submod"], "a") as file:
file.write(
ub.codeblock("""
print('NESTED SIDE EFFECT')
"""))
return paths
def test_cancel(ActorClass, F=0.01):
"""
F is a factor to control wait time
CommandLine:
python -m futures_actors.tests test_cancel:0
python -m futures_actors.tests test_cancel:1
Ignore:
from futures_actors.tests import * # NOQA
ActorClass = TestProcessActor
Example:
>>> from futures_actors.tests import * # NOQA
>>> test_cancel(TestProcessActor)
Example:
>>> from futures_actors.tests import * # NOQA
>>> test_cancel(TestThreadActor)
"""
import shutil
print('Test cancel for {}'.format(ActorClass))
test_state = {'num': False}
def done_callback(f):
try:
num = f.result()
except futures.CancelledError:
num = 'canceled'
print('Canceled task {}'.format(f))
else:
test_state['num'] += num
print('DONE CALLBACK GOT = {}'.format(num))
cache_dpath = ub.ensure_app_cache_dir('futures_actors', 'tests')
shutil.rmtree(cache_dpath)
ub.ensuredir(cache_dpath)
fpaths = [join(cache_dpath, 'lock{}'.format(i)) for i in range(0, 5)]
executor = ActorClass.executor()
try:
print('Submit task 1')
f1 = executor.post({'action': 'lockfile', 'num': 1, 'fpath': fpaths[1]})
f1.add_done_callback(done_callback)
print('Submit task 2')
f2 = executor.post({'action': 'lockfile', 'num': 2, 'fpath': fpaths[2]})
f2.add_done_callback(done_callback)
print('Submit task 3')
f3 = executor.post({'action': 'lockfile', 'num': 3, 'fpath': fpaths[3]})
f3.add_done_callback(done_callback)
print('Submit task 4')
f4 = executor.post({'action': 'lockfile', 'num': 4, 'fpath': fpaths[4]})
f4.add_done_callback(done_callback)
can_cancel = f3.cancel()
assert can_cancel, 'we should be able to cancel in time'
# Write the files to unlock the processes
for f in fpaths:
ub.touch(f)
f1.result()
f2.result()
f4.result()
finally:
executor.shutdown(wait=True)
num = test_state['num']
assert num == 7, 'f3 was not cancelled. got num={}'.format(num)
shutil.rmtree(cache_dpath)
