def __init__(self, filesystem, logger=None):
self.filesystem = cache_directory(read_only(filesystem))
self.filesystem.desc('/')
self.caps_list = {}
self.results = []
self.logger = logger
self.copier = Copier()
def test_move_file_read_only_mem_dest(self):
with open_fs("mem://") as src, open_fs("mem://") as dst:
src.writetext("file.txt", "Content")
dst_ro = read_only(dst)
with self.assertRaises(ResourceReadOnly):
fs.move.move_file(src, "file.txt", dst_ro, "target.txt")
self.assertTrue(src.exists("file.txt"))
self.assertFalse(dst_ro.exists("target.txt"),
"file should not have been copied over")
def falta_caps(self):
base = self.pathbar.text()
with read_only(OSFS(base)) as ff:
proces = []
folds = []
for i in ff.scandir('/'):
if i.is_dir:
folds.append(i)
for i in folds:
path = join('/', i.name)
try:
for j in ff.scandir(path):
if j.is_file and splitext(
j.name)[1].lower() in video_formats:
proces.append((j, i))
except (PermissionError, DirectoryExpected) as e:
self.loggin.emit("Acceso denegado a" + join(base, i.name),
ERROR)
folds = {}
for filee, fold in proces:
fold = fold.name
filee = filee.name
self.loggin.emit("Procesando: " + join(base, fold),
INFORMATION)
try:
pp = parse2(filee)
if pp.error:
pp = parse(filee)
except Exception as e:
self.loggin.emit(
"Error procesando: " + join(base, fold, filee),
WARNING)
self.loggin.emit(str(e), ERROR)
continue
t1 = transform(pp.title)
if not pp.episode:
continue
t2 = pp.episode
if fold in folds:
if t1 in folds[fold]:
folds[fold][t1].add(int(t2))
else:
tt = best_ed(t1, folds[fold].keys(), gap=2)
if tt in folds[fold]:
folds[fold][tt].add(int(t2))
else:
folds[fold][tt] = set()
folds[fold][tt].add(int(t2))
else:
folds[fold] = {}
folds[fold][t1] = set()
folds[fold][t1].add(int(t2))
# for i in folds.keys():
# for j in folds[i]:
# folds[i][j]=list(set(folds[i][j]))
self.caps_list = folds
def __init__(self, fs_url, base, extensions=("gb", "gbk")):
bases = (AbstractPart, AbstractModule, AbstractVector)
if not isinstance(base, type) or not issubclass(base, (bases)):
raise TypeError("base cannot be '{}'".format(base))
self.fs = read_only(fs.open_fs(fs_url))
self.base = base
self._recurse = False
self._extensions = extensions
def test_move_file_same_fs_read_only_source(self):
with open_fs("temp://") as tmp:
path = tmp.getsyspath("/")
tmp.writetext("file.txt", "Content")
src = read_only(open_fs(path))
dst = tmp.makedir("sub")
with self.assertRaises(ResourceReadOnly):
fs.move.move_file(src, "file.txt", dst, "target_file.txt")
self.assertTrue(src.exists("file.txt"))
self.assertFalse(dst.exists("target_file.txt"),
"file should not have been copied over")
def walk_upload(folder):
if not os.path.isdir(folder):
return
with read_only(cache_directory(open_fs('.'))) as home_fs:
for walker in home_fs.walk(folder):
path = walker.path
ss.headers['JSON-PATH'] = path
for file in walker.files:
name = file.name
ss.headers['JSON-NAME'] = name
with home_fs.open(join(path, name)) as f:
data = f.read()
ss.post(url, data=data)
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)
def last(self, base):
with read_only(OSFS(base)) as ff:
proces = []
folds = []
for i in ff.scandir('/'):
if i.is_dir:
folds.append(i)
for i in folds:
path = join('/', i.name)
try:
for j in ff.scandir(path):
if j.is_file and splitext(
j.name)[1].lower() in video_formats:
proces.append((j, i))
except (PermissionError, DirectoryExpected) as e:
self.logger.emit("Acceso denegado a" + join(base, i.name),
ERROR)
folds = {}
for filee, fold in proces:
fold = fold.name
filee = filee.name
try:
pp = parse2(filee)
if pp.error:
pp = parse(filee)
except Exception as e:
self.logger.emit(
"Error procesando: " + join(base, fold, filee),
WARNING)
self.logger.emit(str(e), ERROR)
continue
t1 = transform(pp.title)
if not pp.episode:
continue
t2 = pp.episode
if t1 in folds:
if folds[t1] < int(t2):
folds[t1] = int(t2)
else:
tt = best_ed(t1, folds.keys())
if tt in folds:
if folds[tt] < int(t2):
folds[tt] = int(t2)
folds[tt] = int(t2)
self.caps_list = folds
def walk_upload(ftp_dir, root_folder, sub_folder):
if not os.path.isdir(root_folder) and not os.path.isdir(sub_folder):
return
os.system(
ftp_command.format(command='cd ' + ftp_dir + sub_folder +
';mput -P 2 ' + root_folder + '/*;'))
with read_only(cache_directory(open_fs(root_folder))) as home_fs:
for dir_path in home_fs.walk.dirs(sub_folder,
exclude_dirs=["*.git", ".github"]):
print("Processing", dir_path)
entry = root_folder + dir_path
os.system(
ftp_command.format(command=mkdir(ftp_dir, dir_path) +
'mput -P 2 ' + entry + '/*;'))
print("Uploaded", dir_path)
def cwd_fs(self) -> FS:
"""
Read-only version of the current working directory.
"""
return read_only(self.root_fs)
def __init__(self, root_fs: FS, config: Config):
super(DryRunSideEffects, self).__init__(root_fs)
self.fragments_fs = read_only(
root_fs.opendir(config.change_fragments_path))
def test_readonly(self):
mem_fs = open_fs("mem://")
fs = wrap.read_only(mem_fs)
with self.assertRaises(errors.ResourceReadOnly):
fs.open("foo", "w")
with self.assertRaises(errors.ResourceReadOnly):
fs.appendtext("foo", "bar")
with self.assertRaises(errors.ResourceReadOnly):
fs.appendbytes("foo", b"bar")
with self.assertRaises(errors.ResourceReadOnly):
fs.makedir("foo")
with self.assertRaises(errors.ResourceReadOnly):
fs.move("foo", "bar")
with self.assertRaises(errors.ResourceReadOnly):
fs.openbin("foo", "w")
with self.assertRaises(errors.ResourceReadOnly):
fs.remove("foo")
with self.assertRaises(errors.ResourceReadOnly):
fs.removedir("foo")
with self.assertRaises(errors.ResourceReadOnly):
fs.setinfo("foo", {})
with self.assertRaises(errors.ResourceReadOnly):
fs.settimes("foo", {})
with self.assertRaises(errors.ResourceReadOnly):
fs.copy("foo", "bar")
with self.assertRaises(errors.ResourceReadOnly):
fs.create("foo")
with self.assertRaises(errors.ResourceReadOnly):
fs.settext("foo", "bar")
with self.assertRaises(errors.ResourceReadOnly):
fs.setbytes("foo", b"bar")
with self.assertRaises(errors.ResourceReadOnly):
fs.makedirs("foo/bar")
with self.assertRaises(errors.ResourceReadOnly):
fs.touch("foo")
with self.assertRaises(errors.ResourceReadOnly):
fs.setbinfile("foo", None)
with self.assertRaises(errors.ResourceReadOnly):
fs.setfile("foo", None)
self.assertTrue(mem_fs.isempty("/"))
mem_fs.setbytes("file", b"read me")
with fs.openbin("file") as read_file:
self.assertEqual(read_file.read(), b"read me")
with fs.open("file", "rb") as read_file:
self.assertEqual(read_file.read(), b"read me")
def make_temp_fs(fff):
# make virtual filesystem in ram with the final
# organization of the filesystem
ff = cache_directory(read_only(fff))
ram = MemoryFS()
# for path, dirs, files in ff.walk():
posprocsub = []
fils = set()
files = ff.scandir('/')
path = '/'
folds = set([i.name for i in files if i.is_dir])
files = ff.scandir('/')
for j in files:
if not j.is_file:
continue
if splitext(j.name)[1] in subs_formats:
posprocsub.append(j.name)
continue
pp = rename(j.name)
if pp.error:
pp = parse(j.name)
try:
if pp.is_video:
fold = transform(pp.title)
if not (fold in folds):
fold = best_ed(fold, folds)
folds.add(fold)
pth = join('/', fold)
if not ram.exists(pth):
ram.makedir(fold)
fils.add(pp.title)
if pp.episode:
if pp.season:
fill = pp.title + ' - ' + \
str(pp.season) + 'X' + str(pp.episode)
else:
fill = pp.title + ' - ' + str(pp.episode)
else:
fill = pp.title
if pp.episode_title:
fill += ' - ' + str(pp.episode_title)
fill += pp.ext
ram.settext(join(pth, fill), join(path, j.name))
except KeyError:
continue
for j in posprocsub:
pp = rename(j)
if pp.error:
pp = parse(j.name)
fold = transform(pp.title)
pth = join('/', fold)
if pp.episode:
if pp.season:
fill = pp.title + ' - ' + \
str(pp.season) + 'X' + str(pp.episode)
else:
fill = fold + ' - ' + str(pp.episode)
else:
fill = fold
if pp.episode_title:
fill = fill + ' - ' + str(pp.episode_title)
fill += pp.ext
if ram.exists(pth):
ram.settext(join(pth, fill), join(path, j))
elif len(fils) == 1:
pth = join('/', list(fils)[0])
ram.settext(join(pth, fill), join(path, j))
elif len(fils) > 1:
best = None
gap = 3
for i in fils:
n = editDistance(i, fold)
if n < 3 and n < gap:
best = i
gap = n
elif n == 0:
best = i
break
if best:
pth = join('/', best)
ram.settext(join(pth, fill), join(path, j))
else:
if not (ram.exists('/subs')):
ram.makedir('/subs')
ram.settext(join('/subs', j), join(path, j))
else:
if not (ram.exists('/subs')):
ram.makedir('/subs')
ram.settext(join('/subs', j), join(path, j))
return ram
def test_readonly(self):
mem_fs = open_fs('mem://')
fs = wrap.read_only(mem_fs)
with self.assertRaises(errors.ResourceReadOnly):
fs.open('foo', 'w')
with self.assertRaises(errors.ResourceReadOnly):
fs.appendtext('foo', 'bar')
with self.assertRaises(errors.ResourceReadOnly):
fs.appendbytes('foo', b'bar')
with self.assertRaises(errors.ResourceReadOnly):
fs.makedir('foo')
with self.assertRaises(errors.ResourceReadOnly):
fs.move('foo', 'bar')
with self.assertRaises(errors.ResourceReadOnly):
fs.openbin('foo', 'w')
with self.assertRaises(errors.ResourceReadOnly):
fs.remove('foo')
with self.assertRaises(errors.ResourceReadOnly):
fs.removedir('foo')
with self.assertRaises(errors.ResourceReadOnly):
fs.setinfo('foo', {})
with self.assertRaises(errors.ResourceReadOnly):
fs.settimes('foo', {})
with self.assertRaises(errors.ResourceReadOnly):
fs.copy('foo', 'bar')
with self.assertRaises(errors.ResourceReadOnly):
fs.create('foo')
with self.assertRaises(errors.ResourceReadOnly):
fs.settext('foo', 'bar')
with self.assertRaises(errors.ResourceReadOnly):
fs.setbytes('foo', b'bar')
with self.assertRaises(errors.ResourceReadOnly):
fs.makedirs('foo/bar')
with self.assertRaises(errors.ResourceReadOnly):
fs.touch('foo')
with self.assertRaises(errors.ResourceReadOnly):
fs.setbinfile('foo', None)
with self.assertRaises(errors.ResourceReadOnly):
fs.setfile('foo', None)
self.assertTrue(mem_fs.isempty('/'))
mem_fs.setbytes('file', b'read me')
with fs.openbin('file') as read_file:
self.assertEqual(read_file.read(), b'read me')
with fs.open('file', 'rb') as read_file:
self.assertEqual(read_file.read(), b'read me')
def open_test_root_fs() -> FS:
"""
Open the filesystem root for the tests.
"""
cwd = os.path.dirname(__file__)
return read_only(open_fs('data', cwd=cwd))
