def test__when_copying_to_non_pyfilesystem__should_raise_runtime_error():
target_fs = NonPyFilesystemBasedFilesystem()
origin_fs = MemoryFS()
origin_fs.create(SOURCE)
sut = _TestFilesystemImpl(origin_fs)
with pytest.raises(RuntimeError):
sut.copy(SOURCE, TARGET, filesystem=target_fs)
def test__when_copying__but_file_exists__should_raise_file_exists_error():
mem_fs = MemoryFS()
mem_fs.create(SOURCE)
mem_fs.create(TARGET)
sut = _TestFilesystemImpl(mem_fs)
with pytest.raises(FileExistsError):
sut.copy(SOURCE, TARGET)
def test__when_copying_to_other_filesystem__but_file_exists__should_raise_file_exists_error(
):
origin_fs = MemoryFS()
origin_fs.create(SOURCE)
target_fs = MemoryFS()
target_fs.create(TARGET)
sut = _TestFilesystemImpl(origin_fs)
with pytest.raises(FileExistsError):
sut.copy(SOURCE, TARGET, filesystem=_TestFilesystemImpl(target_fs))
def test__when_deleting_with_glob_pattern__it_deletes_matching_files():
mem_fs = MemoryFS()
mem_fs.create("hello.txt")
mem_fs.create("world.txt")
mem_fs.create("nope.gif")
sut = _TestFilesystemImpl(mem_fs)
sut.delete("*.txt")
assert not mem_fs.exists("hello.txt")
assert not mem_fs.exists("world.txt")
assert mem_fs.exists("nope.gif")
def test__when_copying_files_with_glob_pattern__it_copies_matching_files():
mem_fs = MemoryFS()
mem_fs.create("hello.txt")
mem_fs.create("world.txt")
mem_fs.create("nope.gif")
sut = _TestFilesystemImpl(mem_fs)
sut.copy("*.txt", "newdir/")
assert mem_fs.exists("newdir/hello.txt")
assert mem_fs.exists("newdir/world.txt")
assert not mem_fs.exists("newdir/nope.gif")
def test__when_globbing__it_returns_matching_paths():
mem_fs = MemoryFS()
mem_fs.create("hello.txt")
mem_fs.create("world.txt")
mem_fs.create("nope.gif")
subfs = mem_fs.makedir("sub")
subfs.create("nomatch.gif")
subfs.create("match.txt")
sut = _TestFilesystemImpl(mem_fs)
actual = sut.glob("**/**.txt")
assert actual == ["hello.txt", "world.txt", "sub/match.txt"]
def test__when_copying_file_to_other_filesystem__and_parent_dir_exists__should_not_try_to_create_dirs(
):
target_parent_dir = "another/folder"
target_fs = MemoryFS()
target_fs.makedirs(target_parent_dir)
target_fs_wrapping_mock = MagicMock(spec=MemoryFS, wraps=target_fs)
origin_fs = MemoryFS()
origin_fs.create(SOURCE)
sut = _TestFilesystemImpl(origin_fs)
complete_path = f"{target_parent_dir}/{TARGET}"
sut.copy(SOURCE,
complete_path,
filesystem=_TestFilesystemImpl(target_fs_wrapping_mock))
target_fs_wrapping_mock.makedirs.assert_not_called()
class TestBoundWalkerBase(unittest.TestCase):
def setUp(self):
"""
Sets up the following file system with empty files:
/
-foo1/
- -top1.txt
- -top2.txt
-foo2/
- -bar1/
- -bar2/
- - -bar3/
- - - -test.txt
- -top3.bin
-foo3/
"""
self.fs = MemoryFS()
self.fs.makedir("foo1")
self.fs.makedir("foo2")
self.fs.makedir("foo3")
self.fs.create("foo1/top1.txt")
self.fs.create("foo1/top2.txt")
self.fs.makedir("foo1/bar1")
self.fs.makedir("foo2/bar2")
self.fs.makedir("foo2/bar2/bar3")
self.fs.create("foo2/bar2/bar3/test.txt")
self.fs.create("foo2/top3.bin")
class TestWalk(unittest.TestCase):
def setUp(self):
self.fs = MemoryFS()
self.fs.makedir('foo1')
self.fs.makedir('foo2')
self.fs.makedir('foo3')
self.fs.create('foo1/top1.txt')
self.fs.create('foo1/top2.txt')
self.fs.makedir('foo1/bar1')
self.fs.makedir('foo2/bar2')
self.fs.makedir('foo2/bar2/bar3')
self.fs.create('foo2/bar2/bar3/test.txt')
self.fs.create('foo2/top3.txt')
def test_invalid(self):
with self.assertRaises(ValueError):
self.fs.walk(search='random')
def test_repr(self):
repr(self.fs.walk)
def test_walk(self):
walk = []
for path, dirs, files in self.fs.walk():
walk.append(
(path, [info.name
for info in dirs], [info.name for info in files]))
expected = [(u'/', [u'foo1', u'foo2', u'foo3'], []),
(u'/foo1', [u'bar1'], [u'top1.txt', u'top2.txt']),
(u'/foo2', [u'bar2'], [u'top3.txt']), (u'/foo3', [], []),
(u'/foo1/bar1', [], []), (u'/foo2/bar2', [u'bar3'], []),
(u'/foo2/bar2/bar3', [], [u'test.txt'])]
self.assertEqual(walk, expected)
def test_walk_files(self):
files = list(self.fs.walk.files())
self.assertEqual(files, [
'/foo1/top1.txt',
'/foo1/top2.txt',
'/foo2/top3.txt',
'/foo2/bar2/bar3/test.txt',
])
files = list(self.fs.walk.files(search="depth"))
self.assertEqual(files, [
'/foo1/top1.txt',
'/foo1/top2.txt',
'/foo2/bar2/bar3/test.txt',
'/foo2/top3.txt',
])
def test_walk_dirs(self):
dirs = list(self.fs.walk.dirs())
self.assertEqual(dirs, [
'/foo1', '/foo2', '/foo3', '/foo1/bar1', '/foo2/bar2',
'/foo2/bar2/bar3'
])
dirs = list(self.fs.walk.dirs(search="depth"))
self.assertEqual(dirs, [
'/foo1/bar1', '/foo2/bar2/bar3', '/foo2/bar2', '/foo1', '/foo2',
'/foo3'
])
dirs = list(self.fs.walk.dirs(search="depth", exclude_dirs=['foo2']))
self.assertEqual(dirs, ['/foo1/bar1', '/foo1', '/foo3'])
def test_walk_info(self):
walk = []
for path, info in self.fs.walk.info():
walk.append((path, info.is_dir, info.name))
expected = [(u'/foo1', True, u'foo1'), (u'/foo2', True, u'foo2'),
(u'/foo3', True, u'foo3'), (u'/foo1/bar1', True, u'bar1'),
(u'/foo1/top1.txt', False, u'top1.txt'),
(u'/foo1/top2.txt', False, u'top2.txt'),
(u'/foo2/bar2', True, u'bar2'),
(u'/foo2/top3.txt', False, u'top3.txt'),
(u'/foo2/bar2/bar3', True, u'bar3'),
(u'/foo2/bar2/bar3/test.txt', False, u'test.txt')]
self.assertEqual(walk, expected)
def test_broken(self):
original_scandir = self.fs.scandir
def broken_scandir(path, namespaces=None):
if path == '/foo2':
raise FSError("can't read dir")
return original_scandir(path, namespaces=namespaces)
self.fs.scandir = broken_scandir
files = list(self.fs.walk.files(search="depth", ignore_errors=True))
self.assertEqual(files, ['/foo1/top1.txt', '/foo1/top2.txt'])
with self.assertRaises(FSError):
list(self.fs.walk.files(on_error=lambda path, error: False))
def test_on_error_invalid(self):
with self.assertRaises(TypeError):
walk.Walker(on_error='nope')
class TestWalk(unittest.TestCase):
def setUp(self):
self.fs = MemoryFS()
self.fs.makedir('foo1')
self.fs.makedir('foo2')
self.fs.makedir('foo3')
self.fs.create('foo1/top1.txt')
self.fs.create('foo1/top2.txt')
self.fs.makedir('foo1/bar1')
self.fs.makedir('foo2/bar2')
self.fs.makedir('foo2/bar2/bar3')
self.fs.create('foo2/bar2/bar3/test.txt')
self.fs.create('foo2/top3.bin')
def test_invalid(self):
with self.assertRaises(ValueError):
self.fs.walk(search='random')
def test_repr(self):
repr(self.fs.walk)
def test_walk(self):
_walk = []
for step in self.fs.walk():
self.assertIsInstance(step, walk.Step)
path, dirs, files = step
_walk.append(
(path, [info.name
for info in dirs], [info.name for info in files]))
expected = [(u'/', [u'foo1', u'foo2', u'foo3'], []),
(u'/foo1', [u'bar1'], [u'top1.txt', u'top2.txt']),
(u'/foo2', [u'bar2'], [u'top3.bin']), (u'/foo3', [], []),
(u'/foo1/bar1', [], []), (u'/foo2/bar2', [u'bar3'], []),
(u'/foo2/bar2/bar3', [], [u'test.txt'])]
self.assertEqual(_walk, expected)
def test_walk_depth(self):
_walk = []
for step in self.fs.walk(search='depth'):
self.assertIsInstance(step, walk.Step)
path, dirs, files = step
_walk.append(
(path, [info.name
for info in dirs], [info.name for info in files]))
expected = [(u'/foo1/bar1', [], []),
(u'/foo1', [u'bar1'], [u'top1.txt', u'top2.txt']),
(u'/foo2/bar2/bar3', [], [u'test.txt']),
(u'/foo2/bar2', [u'bar3'], []),
(u'/foo2', [u'bar2'], [u'top3.bin']), (u'/foo3', [], []),
(u'/', [u'foo1', u'foo2', u'foo3'], [])]
self.assertEqual(_walk, expected)
def test_walk_directory(self):
_walk = []
for step in self.fs.walk('foo2'):
self.assertIsInstance(step, walk.Step)
path, dirs, files = step
_walk.append(
(path, [info.name
for info in dirs], [info.name for info in files]))
expected = [(u'/foo2', [u'bar2'], [u'top3.bin']),
(u'/foo2/bar2', [u'bar3'], []),
(u'/foo2/bar2/bar3', [], [u'test.txt'])]
self.assertEqual(_walk, expected)
def test_walk_levels_1(self):
results = list(self.fs.walk(max_depth=1))
self.assertEqual(len(results), 1)
dirs = sorted(info.name for info in results[0].dirs)
self.assertEqual(dirs, ['foo1', 'foo2', 'foo3'])
files = sorted(info.name for info in results[0].files)
self.assertEqual(files, [])
def test_walk_levels_1_depth(self):
results = list(self.fs.walk(max_depth=1, search='depth'))
self.assertEqual(len(results), 1)
dirs = sorted(info.name for info in results[0].dirs)
self.assertEqual(dirs, ['foo1', 'foo2', 'foo3'])
files = sorted(info.name for info in results[0].files)
self.assertEqual(files, [])
def test_walk_levels_2(self):
_walk = []
for step in self.fs.walk(max_depth=2):
self.assertIsInstance(step, walk.Step)
path, dirs, files = step
_walk.append((path, sorted(info.name for info in dirs),
sorted(info.name for info in files)))
expected = [(u'/', [u'foo1', u'foo2', u'foo3'], []),
(u'/foo1', [u'bar1'], [u'top1.txt', u'top2.txt']),
(u'/foo2', [u'bar2'], [u'top3.bin']), (u'/foo3', [], [])]
self.assertEqual(_walk, expected)
def test_walk_files(self):
files = list(self.fs.walk.files())
self.assertEqual(files, [
'/foo1/top1.txt',
'/foo1/top2.txt',
'/foo2/top3.bin',
'/foo2/bar2/bar3/test.txt',
])
files = list(self.fs.walk.files(search="depth"))
self.assertEqual(files, [
'/foo1/top1.txt',
'/foo1/top2.txt',
'/foo2/bar2/bar3/test.txt',
'/foo2/top3.bin',
])
def test_walk_dirs(self):
dirs = list(self.fs.walk.dirs())
self.assertEqual(dirs, [
'/foo1', '/foo2', '/foo3', '/foo1/bar1', '/foo2/bar2',
'/foo2/bar2/bar3'
])
dirs = list(self.fs.walk.dirs(search="depth"))
self.assertEqual(dirs, [
'/foo1/bar1', '/foo1', '/foo2/bar2/bar3', '/foo2/bar2', '/foo2',
'/foo3'
])
dirs = list(self.fs.walk.dirs(search="depth", exclude_dirs=['foo2']))
self.assertEqual(dirs, ['/foo1/bar1', '/foo1', '/foo3'])
def test_walk_files_filter(self):
files = list(self.fs.walk.files(filter=['*.txt']))
self.assertEqual(files, [
'/foo1/top1.txt',
'/foo1/top2.txt',
'/foo2/bar2/bar3/test.txt',
])
files = list(self.fs.walk.files(search="depth", filter=['*.txt']))
self.assertEqual(files, [
'/foo1/top1.txt',
'/foo1/top2.txt',
'/foo2/bar2/bar3/test.txt',
])
files = list(self.fs.walk.files(filter=['*.bin']))
self.assertEqual(files, ['/foo2/top3.bin'])
files = list(self.fs.walk.files(filter=['*.nope']))
self.assertEqual(files, [])
def test_walk_info(self):
walk = []
for path, info in self.fs.walk.info():
walk.append((path, info.is_dir, info.name))
expected = [(u'/foo1', True, u'foo1'), (u'/foo2', True, u'foo2'),
(u'/foo3', True, u'foo3'),
(u'/foo1/top1.txt', False, u'top1.txt'),
(u'/foo1/top2.txt', False, u'top2.txt'),
(u'/foo1/bar1', True, u'bar1'),
(u'/foo2/bar2', True, u'bar2'),
(u'/foo2/top3.bin', False, u'top3.bin'),
(u'/foo2/bar2/bar3', True, u'bar3'),
(u'/foo2/bar2/bar3/test.txt', False, u'test.txt')]
self.assertEqual(walk, expected)
def test_broken(self):
original_scandir = self.fs.scandir
def broken_scandir(path, namespaces=None):
if path == '/foo2':
raise FSError("can't read dir")
return original_scandir(path, namespaces=namespaces)
self.fs.scandir = broken_scandir
files = list(self.fs.walk.files(search="depth", ignore_errors=True))
self.assertEqual(files, ['/foo1/top1.txt', '/foo1/top2.txt'])
with self.assertRaises(FSError):
list(self.fs.walk.files(on_error=lambda path, error: False))
def test_on_error_invalid(self):
with self.assertRaises(TypeError):
walk.Walker(on_error='nope')
def test_subdir_uses_same_walker(self):
class CustomWalker(walk.Walker):
@classmethod
def bind(cls, fs):
return walk.BoundWalker(fs, walker_class=CustomWalker)
class CustomizedMemoryFS(MemoryFS):
walker_class = CustomWalker
base_fs = CustomizedMemoryFS()
base_fs.settext("a", "a")
base_fs.makedirs("b")
base_fs.settext("b/c", "c")
base_fs.settext("b/d", "d")
base_walker = base_fs.walk
self.assertEqual(base_walker.walker_class, CustomWalker)
six.assertCountEqual(self, ["/a", "/b/c", "/b/d"], base_walker.files())
sub_fs = base_fs.opendir("b")
sub_walker = sub_fs.walk
self.assertEqual(sub_walker.walker_class, CustomWalker)
six.assertCountEqual(self, ["/c", "/d"], sub_walker.files())
def test_readonly_wrapper_uses_same_walker(self):
class CustomWalker(walk.Walker):
@classmethod
def bind(cls, fs):
return walk.BoundWalker(fs, walker_class=CustomWalker)
class CustomizedMemoryFS(MemoryFS):
walker_class = CustomWalker
base_fs = CustomizedMemoryFS()
base_walker = base_fs.walk
self.assertEqual(base_walker.walker_class, CustomWalker)
readonly_fs = read_only(CustomizedMemoryFS())
readonly_walker = readonly_fs.walk
self.assertEqual(readonly_walker.walker_class, CustomWalker)
import dokanmount
import os.path
import tempfile
from fs.osfs import OSFS
from fs.memoryfs import MemoryFS
from shutil import rmtree
from six import b
path = tempfile.mkdtemp()
try:
#fs = OSFS(path)
fs = MemoryFS()
fs.create('test.txt')
fs.appendtext('test.txt',
'This is a test file',
encoding=u'utf-8',
errors=None,
newline=u'')
fs.makedir("TestDir")
fs.create('TestDir/subtest.txt')
fs.appendtext('TestDir/subtest.txt',
'This is a test file in a subfolder',
encoding=u'utf-8',
errors=None,
newline=u'')
flags = dokanmount.DOKAN_OPTION_DEBUG | dokanmount.DOKAN_OPTION_STDERR | dokanmount.DOKAN_OPTION_REMOVABLE
a = dokanmount.mount(fs,
"Q:\\",
foreground=True,
numthreads=2,
flags=flags)
#fs.close()
class TestWalk(unittest.TestCase):
def setUp(self):
self.fs = MemoryFS()
self.fs.makedir("foo1")
self.fs.makedir("foo2")
self.fs.makedir("foo3")
self.fs.create("foo1/top1.txt")
self.fs.create("foo1/top2.txt")
self.fs.makedir("foo1/bar1")
self.fs.makedir("foo2/bar2")
self.fs.makedir("foo2/bar2/bar3")
self.fs.create("foo2/bar2/bar3/test.txt")
self.fs.create("foo2/top3.bin")
def test_invalid(self):
with self.assertRaises(ValueError):
self.fs.walk(search="random")
def test_repr(self):
repr(self.fs.walk)
def test_walk(self):
_walk = []
for step in self.fs.walk():
self.assertIsInstance(step, walk.Step)
path, dirs, files = step
_walk.append(
(path, [info.name for info in dirs], [info.name for info in files])
)
expected = [
("/", ["foo1", "foo2", "foo3"], []),
("/foo1", ["bar1"], ["top1.txt", "top2.txt"]),
("/foo2", ["bar2"], ["top3.bin"]),
("/foo3", [], []),
("/foo1/bar1", [], []),
("/foo2/bar2", ["bar3"], []),
("/foo2/bar2/bar3", [], ["test.txt"]),
]
self.assertEqual(_walk, expected)
def test_walk_filter_dirs(self):
_walk = []
for step in self.fs.walk(filter_dirs=["foo*"]):
self.assertIsInstance(step, walk.Step)
path, dirs, files = step
_walk.append(
(path, [info.name for info in dirs], [info.name for info in files])
)
expected = [
("/", ["foo1", "foo2", "foo3"], []),
("/foo1", [], ["top1.txt", "top2.txt"]),
("/foo2", [], ["top3.bin"]),
("/foo3", [], []),
]
self.assertEqual(_walk, expected)
def test_walk_depth(self):
_walk = []
for step in self.fs.walk(search="depth"):
self.assertIsInstance(step, walk.Step)
path, dirs, files = step
_walk.append(
(path, [info.name for info in dirs], [info.name for info in files])
)
expected = [
("/foo1/bar1", [], []),
("/foo1", ["bar1"], ["top1.txt", "top2.txt"]),
("/foo2/bar2/bar3", [], ["test.txt"]),
("/foo2/bar2", ["bar3"], []),
("/foo2", ["bar2"], ["top3.bin"]),
("/foo3", [], []),
("/", ["foo1", "foo2", "foo3"], []),
]
self.assertEqual(_walk, expected)
def test_walk_directory(self):
_walk = []
for step in self.fs.walk("foo2"):
self.assertIsInstance(step, walk.Step)
path, dirs, files = step
_walk.append(
(path, [info.name for info in dirs], [info.name for info in files])
)
expected = [
("/foo2", ["bar2"], ["top3.bin"]),
("/foo2/bar2", ["bar3"], []),
("/foo2/bar2/bar3", [], ["test.txt"]),
]
self.assertEqual(_walk, expected)
def test_walk_levels_1(self):
results = list(self.fs.walk(max_depth=1))
self.assertEqual(len(results), 1)
dirs = sorted(info.name for info in results[0].dirs)
self.assertEqual(dirs, ["foo1", "foo2", "foo3"])
files = sorted(info.name for info in results[0].files)
self.assertEqual(files, [])
def test_walk_levels_1_depth(self):
results = list(self.fs.walk(max_depth=1, search="depth"))
self.assertEqual(len(results), 1)
dirs = sorted(info.name for info in results[0].dirs)
self.assertEqual(dirs, ["foo1", "foo2", "foo3"])
files = sorted(info.name for info in results[0].files)
self.assertEqual(files, [])
def test_walk_levels_2(self):
_walk = []
for step in self.fs.walk(max_depth=2):
self.assertIsInstance(step, walk.Step)
path, dirs, files = step
_walk.append(
(
path,
sorted(info.name for info in dirs),
sorted(info.name for info in files),
)
)
expected = [
("/", ["foo1", "foo2", "foo3"], []),
("/foo1", ["bar1"], ["top1.txt", "top2.txt"]),
("/foo2", ["bar2"], ["top3.bin"]),
("/foo3", [], []),
]
self.assertEqual(_walk, expected)
def test_walk_files(self):
files = list(self.fs.walk.files())
self.assertEqual(
files,
[
"/foo1/top1.txt",
"/foo1/top2.txt",
"/foo2/top3.bin",
"/foo2/bar2/bar3/test.txt",
],
)
files = list(self.fs.walk.files(search="depth"))
self.assertEqual(
files,
[
"/foo1/top1.txt",
"/foo1/top2.txt",
"/foo2/bar2/bar3/test.txt",
"/foo2/top3.bin",
],
)
def test_walk_dirs(self):
dirs = list(self.fs.walk.dirs())
self.assertEqual(
dirs,
["/foo1", "/foo2", "/foo3", "/foo1/bar1", "/foo2/bar2", "/foo2/bar2/bar3"],
)
dirs = list(self.fs.walk.dirs(search="depth"))
self.assertEqual(
dirs,
["/foo1/bar1", "/foo1", "/foo2/bar2/bar3", "/foo2/bar2", "/foo2", "/foo3"],
)
dirs = list(self.fs.walk.dirs(search="depth", exclude_dirs=["foo2"]))
self.assertEqual(dirs, ["/foo1/bar1", "/foo1", "/foo3"])
def test_walk_files_filter(self):
files = list(self.fs.walk.files(filter=["*.txt"]))
self.assertEqual(
files, ["/foo1/top1.txt", "/foo1/top2.txt", "/foo2/bar2/bar3/test.txt"]
)
files = list(self.fs.walk.files(search="depth", filter=["*.txt"]))
self.assertEqual(
files, ["/foo1/top1.txt", "/foo1/top2.txt", "/foo2/bar2/bar3/test.txt"]
)
files = list(self.fs.walk.files(filter=["*.bin"]))
self.assertEqual(files, ["/foo2/top3.bin"])
files = list(self.fs.walk.files(filter=["*.nope"]))
self.assertEqual(files, [])
def test_walk_files_exclude(self):
# Test exclude argument works
files = list(self.fs.walk.files(exclude=["*.txt"]))
self.assertEqual(files, ["/foo2/top3.bin"])
# Test exclude doesn't break filter
files = list(self.fs.walk.files(filter=["*.bin"], exclude=["*.txt"]))
self.assertEqual(files, ["/foo2/top3.bin"])
# Test excluding everything
files = list(self.fs.walk.files(exclude=["*"]))
self.assertEqual(files, [])
def test_walk_info(self):
walk = []
for path, info in self.fs.walk.info():
walk.append((path, info.is_dir, info.name))
expected = [
("/foo1", True, "foo1"),
("/foo2", True, "foo2"),
("/foo3", True, "foo3"),
("/foo1/top1.txt", False, "top1.txt"),
("/foo1/top2.txt", False, "top2.txt"),
("/foo1/bar1", True, "bar1"),
("/foo2/bar2", True, "bar2"),
("/foo2/top3.bin", False, "top3.bin"),
("/foo2/bar2/bar3", True, "bar3"),
("/foo2/bar2/bar3/test.txt", False, "test.txt"),
]
self.assertEqual(walk, expected)
def test_broken(self):
original_scandir = self.fs.scandir
def broken_scandir(path, namespaces=None):
if path == "/foo2":
raise FSError("can't read dir")
return original_scandir(path, namespaces=namespaces)
self.fs.scandir = broken_scandir
files = list(self.fs.walk.files(search="depth", ignore_errors=True))
self.assertEqual(files, ["/foo1/top1.txt", "/foo1/top2.txt"])
with self.assertRaises(FSError):
list(self.fs.walk.files(on_error=lambda path, error: False))
def test_on_error_invalid(self):
with self.assertRaises(TypeError):
walk.Walker(on_error="nope")
def test_subdir_uses_same_walker(self):
class CustomWalker(walk.Walker):
@classmethod
def bind(cls, fs):
return walk.BoundWalker(fs, walker_class=CustomWalker)
class CustomizedMemoryFS(MemoryFS):
walker_class = CustomWalker
base_fs = CustomizedMemoryFS()
base_fs.writetext("a", "a")
base_fs.makedirs("b")
base_fs.writetext("b/c", "c")
base_fs.writetext("b/d", "d")
base_walker = base_fs.walk
self.assertEqual(base_walker.walker_class, CustomWalker)
six.assertCountEqual(self, ["/a", "/b/c", "/b/d"], base_walker.files())
sub_fs = base_fs.opendir("b")
sub_walker = sub_fs.walk
self.assertEqual(sub_walker.walker_class, CustomWalker)
six.assertCountEqual(self, ["/c", "/d"], sub_walker.files())
def test_readonly_wrapper_uses_same_walker(self):
class CustomWalker(walk.Walker):
@classmethod
def bind(cls, fs):
return walk.BoundWalker(fs, walker_class=CustomWalker)
class CustomizedMemoryFS(MemoryFS):
walker_class = CustomWalker
base_fs = CustomizedMemoryFS()
base_walker = base_fs.walk
self.assertEqual(base_walker.walker_class, CustomWalker)
readonly_fs = read_only(CustomizedMemoryFS())
readonly_walker = readonly_fs.walk
self.assertEqual(readonly_walker.walker_class, CustomWalker)
class TestInfo(unittest.TestCase):
def setUp(self):
self.fs = MemoryFS()
self.fs.makedir("foo")
self.fs.makedir("bar")
self.fs.makedir("baz")
self.fs.makedirs("foo/egg1")
self.fs.makedirs("foo/egg2")
self.fs.create("/root1")
self.fs.create("/root2")
self.fs.create("/foo/test.txt")
self.fs.create("/foo/test2.txt")
self.fs.create("/foo/.hidden")
self.fs.makedirs("/deep/deep1/deep2/deep3/deep4/deep5/deep6")
def test_tree(self):
output_file = io.StringIO()
tree.render(self.fs, file=output_file)
expected = "|-- bar\n|-- baz\n|-- deep\n| `-- deep1\n| `-- deep2\n| `-- deep3\n| `-- deep4\n| `-- deep5\n|-- foo\n| |-- egg1\n| |-- egg2\n| |-- .hidden\n| |-- test.txt\n| `-- test2.txt\n|-- root1\n`-- root2\n"
self.assertEqual(output_file.getvalue(), expected)
def test_tree_encoding(self):
output_file = io.StringIO()
tree.render(self.fs, file=output_file, with_color=True)
print(repr(output_file.getvalue()))
expected = "\x1b[32m\u251c\u2500\u2500\x1b[0m \x1b[1;34mbar\x1b[0m\n\x1b[32m\u251c\u2500\u2500\x1b[0m \x1b[1;34mbaz\x1b[0m\n\x1b[32m\u251c\u2500\u2500\x1b[0m \x1b[1;34mdeep\x1b[0m\n\x1b[32m\u2502 \u2514\u2500\u2500\x1b[0m \x1b[1;34mdeep1\x1b[0m\n\x1b[32m\u2502 \u2514\u2500\u2500\x1b[0m \x1b[1;34mdeep2\x1b[0m\n\x1b[32m\u2502 \u2514\u2500\u2500\x1b[0m \x1b[1;34mdeep3\x1b[0m\n\x1b[32m\u2502 \u2514\u2500\u2500\x1b[0m \x1b[1;34mdeep4\x1b[0m\n\x1b[32m\u2502 \u2514\u2500\u2500\x1b[0m \x1b[1;34mdeep5\x1b[0m\n\x1b[32m\u251c\u2500\u2500\x1b[0m \x1b[1;34mfoo\x1b[0m\n\x1b[32m\u2502 \u251c\u2500\u2500\x1b[0m \x1b[1;34megg1\x1b[0m\n\x1b[32m\u2502 \u251c\u2500\u2500\x1b[0m \x1b[1;34megg2\x1b[0m\n\x1b[32m\u2502 \u251c\u2500\u2500\x1b[0m \x1b[33m.hidden\x1b[0m\n\x1b[32m\u2502 \u251c\u2500\u2500\x1b[0m test.txt\n\x1b[32m\u2502 \u2514\u2500\u2500\x1b[0m test2.txt\n\x1b[32m\u251c\u2500\u2500\x1b[0m root1\n\x1b[32m\u2514\u2500\u2500\x1b[0m root2\n"
self.assertEqual(output_file.getvalue(), expected)
def test_tree_bytes_no_dirs_first(self):
output_file = io.StringIO()
tree.render(self.fs, file=output_file, dirs_first=False)
expected = "|-- bar\n|-- baz\n|-- deep\n| `-- deep1\n| `-- deep2\n| `-- deep3\n| `-- deep4\n| `-- deep5\n|-- foo\n| |-- .hidden\n| |-- egg1\n| |-- egg2\n| |-- test.txt\n| `-- test2.txt\n|-- root1\n`-- root2\n"
self.assertEqual(output_file.getvalue(), expected)
def test_error(self):
output_file = io.StringIO()
filterdir = self.fs.filterdir
def broken_filterdir(path, **kwargs):
if path.startswith("/deep/deep1/"):
# Because error messages differ accross Python versions
raise Exception("integer division or modulo by zero")
return filterdir(path, **kwargs)
self.fs.filterdir = broken_filterdir
tree.render(self.fs, file=output_file, with_color=True)
expected = "\x1b[32m\u251c\u2500\u2500\x1b[0m \x1b[1;34mbar\x1b[0m\n\x1b[32m\u251c\u2500\u2500\x1b[0m \x1b[1;34mbaz\x1b[0m\n\x1b[32m\u251c\u2500\u2500\x1b[0m \x1b[1;34mdeep\x1b[0m\n\x1b[32m\u2502 \u2514\u2500\u2500\x1b[0m \x1b[1;34mdeep1\x1b[0m\n\x1b[32m\u2502 \u2514\u2500\u2500\x1b[0m \x1b[1;34mdeep2\x1b[0m\n\x1b[32m\u2502 \u2514\u2500\u2500\x1b[0m \x1b[31merror (integer division or modulo by zero)\x1b[0m\n\x1b[32m\u251c\u2500\u2500\x1b[0m \x1b[1;34mfoo\x1b[0m\n\x1b[32m\u2502 \u251c\u2500\u2500\x1b[0m \x1b[1;34megg1\x1b[0m\n\x1b[32m\u2502 \u251c\u2500\u2500\x1b[0m \x1b[1;34megg2\x1b[0m\n\x1b[32m\u2502 \u251c\u2500\u2500\x1b[0m \x1b[33m.hidden\x1b[0m\n\x1b[32m\u2502 \u251c\u2500\u2500\x1b[0m test.txt\n\x1b[32m\u2502 \u2514\u2500\u2500\x1b[0m test2.txt\n\x1b[32m\u251c\u2500\u2500\x1b[0m root1\n\x1b[32m\u2514\u2500\u2500\x1b[0m root2\n"
tree_output = output_file.getvalue()
print(repr(tree_output))
self.assertEqual(expected, tree_output)
output_file = io.StringIO()
tree.render(self.fs, file=output_file, with_color=False)
expected = "|-- bar\n|-- baz\n|-- deep\n| `-- deep1\n| `-- deep2\n| `-- error (integer division or modulo by zero)\n|-- foo\n| |-- egg1\n| |-- egg2\n| |-- .hidden\n| |-- test.txt\n| `-- test2.txt\n|-- root1\n`-- root2\n"
self.assertEqual(expected, output_file.getvalue())
import dokanmount
import os.path
import tempfile
from fs.osfs import OSFS
from fs.memoryfs import MemoryFS
from shutil import rmtree
from six import b
fs = MemoryFS()
fs.create('test.txt')
fs.appendtext('test.txt',
'This is a test file',
encoding=u'utf-8',
errors=None,
newline=u'')
fs.makedir("TestDir")
fs.create('TestDir/subtest.txt')
fs.appendtext('TestDir/subtest.txt',
'This is a test file in a subfolder',
encoding=u'utf-8',
errors=None,
newline=u'')
#flags = dokanmount.DOKAN_OPTION_DEBUG | dokanmount.DOKAN_OPTION_STDERR | dokanmount.DOKAN_OPTION_REMOVABLE
flags = dokanmount.DOKAN_OPTION_REMOVABLE
dm = dokanmount.mount(fs, "Q:\\", foreground=False, numthreads=2, flags=flags)
print("Memory FS is now mounted!")
input("Press any key to create file...")
fs.create('PostMountCreatedFile.txt')
fs.appendtext('PostMountCreatedFile.txt',
'This is a file was populated after Dokan mounted',
encoding=u'utf-8',
import csv
import json
import tempfile
from fs.memoryfs import MemoryFS
import numpy as np
fsys = MemoryFS()
fsys.makedir('raw_data')
fsys.makedir('result_data')
fsys.makedir('result_data/dataset_200_step/')
pure_path = 'result_data/dataset_200_step/'
fsys.create(pure_path + 'a.tfrecord')
fsys.create(pure_path + 'b.tfrecord')
fsys.create(pure_path + 'log.log')
fsys.tree()
fsys.removetree(pure_path)
fsys.tree()
path = relpath(normpath(path))
path = path.replace("__colon__", ":")
if not self.allow_autorun:
if path.lower().startswith("autorun."):
path = "_" + path
return path
if __name__ == "__main__":
import os.path
import tempfile
from fs.osfs import OSFS
from fs.memoryfs import MemoryFS
from shutil import rmtree
from six import b
path = tempfile.mkdtemp()
try:
#fs = OSFS(path)
fs = MemoryFS()
fs.create('test.txt')
fs.appendtext('test.txt',
'this is a test',
encoding=u'utf-8',
errors=None,
newline=u'')
flags = DOKAN_OPTION_DEBUG | DOKAN_OPTION_STDERR | DOKAN_OPTION_REMOVABLE
mount(fs, "Q:\\", foreground=True, numthreads=1, flags=flags)
fs.close()
finally:
rmtree(path)
from fs.memoryfs import MemoryFS
mem_fs = MemoryFS()
mem_fs.makedirs("HelloMem")
mem_fs.create("./hello.mem")
print(mem_fs.listdir("./"))
