def test_format_string(self, answer, base, ext, delim, start, end, pad, brackets):
seq_name = SeqName(
base=base,
extension=ext,
delim=delim,
start=start,
end=end,
pad=pad,
brackets=brackets,
)
assert seq_name.formatted() == answer
assert str(seq_name) == answer
def test_alter_seq_name(self, changes_dict):
this_field: Field
original = SeqName(base="file", extension="exr", start=100)
new = original.alter(**changes_dict)
print(f"org: {original}\nnew: {new}\nchanges:{changes_dict}")
for this_field in fields(original):
try:
value = changes_dict[this_field.name]
except KeyError:
value = getattr(original, this_field.name)
assert getattr(new, this_field.name) == value
def test_from_path(self, path, start, end, brackets):
seq_name = SeqName.from_path(path)
assert seq_name.base == "file_name"
assert seq_name.delim == "."
assert seq_name.start == start
assert seq_name.end == end
assert seq_name.pad == 2
assert seq_name.brackets is brackets
assert seq_name.extension == ".exr"
def test_init_defaults(self):
seq_name = SeqName("file_name", ".exr")
assert seq_name.base == "file_name"
assert seq_name.extension == ".exr"
assert seq_name.delim == "."
assert seq_name.start == "#"
assert seq_name.end is None
assert seq_name.pad == 0
assert seq_name.brackets is None
def test_is_frozen(self):
seq_name = SeqName("name", "exr")
with pytest.raises(AttributeError):
seq_name.base = "file"
def test_alter_extension_adds_period(self):
original = SeqName(base="file", extension="exr", start=100)
new = original.alter(extension="dpx")
print(f"new_extension: {new.extension}")
assert new.extension == ".dpx"
def from_path_override_padding(self):
seq_name = SeqName.from_path("file_name.1234567.exr")
assert seq_name.pad == 7
seq_name = SeqName.from_path("file_name.1234567.exr", pad=0)
assert seq_name.pad == 0
def test_extension_none(self):
assert SeqName("file_name", None).extension is None
def test_add_extension_period(self):
assert SeqName("file_name", "exr").extension == ".exr"
class TestSeqDisk:
@pytest.mark.parametrize(
"file_method,src_remains",
[(FileSequence.move_iter, False), (FileSequence.copy_iter, True)],
)
@pytest.mark.parametrize("str_dst", [False, True])
def test_copy_move_iter(self, file_seq_for_operation, file_method,
src_remains, str_dst):
src: FileSequence
dst: Path
src, dst = file_seq_for_operation
dst_arg = str(dst) if str_dst else dst
paths = list()
for item in file_method(src, dst_arg):
print(f"copied/moved: {item}")
paths.append(item)
assert len(paths) == 102
new_file = paths.pop(-1)
assert isinstance(new_file, FileSequence)
assert all(isinstance(x, Path) for x in paths)
assert new_file.path == dst / src.path.name
for i_old, this_path in enumerate(src, 1):
print(this_path.exists(), this_path)
assert this_path.exists(
) if src_remains else not this_path.exists()
for i_new, this_path in enumerate(new_file, 1):
assert this_path.exists()
assert this_path.read_text() == str(i_new + 99)
assert i_new == i_old == 101
print("Source Dir ls:")
for i, x in enumerate(src.path.parent.iterdir(), 1):
print(f"{i}: {x}")
print("-----------")
print("Destination Dir ls:")
for i, x in enumerate(dst.iterdir(), 1):
print(f"{i}: {x}")
@pytest.mark.parametrize(
"file_method,src_remains",
[(FileSequence.move, False), (FileSequence.copy, True)],
)
@pytest.mark.parametrize("str_dst", [False, True])
def test_copy_move(self, file_method, file_seq_for_operation, src_remains,
str_dst):
src: FileSequence
dst: Path
src, dst = file_seq_for_operation
dst_arg = str(dst) if str_dst else dst
new_file = file_method(src, dst_arg)
assert isinstance(new_file, FileSequence)
assert new_file.path == dst / src.path.name
for i_old, this_path in enumerate(src, 1):
print(this_path.exists(), this_path)
assert this_path.exists(
) if src_remains else not this_path.exists()
for i_new, this_path in enumerate(new_file, 1):
assert this_path.exists()
assert this_path.read_text() == str(i_new + 99)
assert len(src) == len(new_file)
print("Source Dir ls:")
for i, x in enumerate(src.path.parent.iterdir(), 1):
print(f"{i}: {x}")
print("-----------")
print("Destination Dir ls:")
for i, x in enumerate(dst.iterdir(), 1):
print(f"{i}: {x}")
@pytest.mark.parametrize(
"new_name, base_name, start_frame, padding, ext, use_iter",
[
("new_name.0100.dpx", "new_name", 100, 4, "dpx", True),
("new_name.0100.dpx", "new_name", 100, 4, "dpx", False),
("new_name.####.dpx", "new_name", 100, 4, "dpx", False),
("new_name.0200.dpx", "new_name", 200, 4, "dpx", True),
("new_name.0200.dpx", "new_name", 200, 4, "dpx", False),
(
SeqName("new_name", "dpx", start=200, pad=4),
"new_name",
200,
4,
"dpx",
False,
),
(FileName("new_name", "dpx"), "new_name", 100, 3, "dpx", False),
("file.090.txt", "file", 90, 3, "txt", False),
("file.110.txt", "file", 110, 3, "txt", False),
("file.110.txt", "file", 110, 3, "txt", False),
],
)
def test_rename(
self,
file_seq_for_operation,
new_name,
base_name,
start_frame,
padding,
ext,
use_iter,
):
src: FileSequence
dst: Path
src, dst = file_seq_for_operation
print("Original Dir List")
for x in sorted(list(src.path.parent.iterdir())):
print(x)
print("------------------")
assert all(x.exists() for x in src)
if use_iter:
for item in src.rename_iter(new_name):
try:
path_old, path_new = item
print(f"{path_old} -> {path_new}")
except ValueError:
file_new = item
else:
assert isinstance(path_old, Path)
assert isinstance(path_new, Path)
assert path_new.name != path_old.name
assert path_new.parent == path_old.parent
assert not path_old.exists()
assert path_new.exists()
else:
file_new = src.rename(new_name)
print("------------------")
print("Post-rename Dir List")
for x in sorted(list(src.path.parent.iterdir())):
print(x)
for num, contents, path in zip(count(start_frame), count(100),
file_new):
assert path.name == f"{base_name}.{str(num).zfill(padding)}.{ext}"
assert path.read_text() == str(contents)
assert file_new.path.parent == src.path.parent
assert file_new.path.name == (
f"{base_name}.{str(start_frame).zfill(padding)}.{ext}")
print("------------------")
print("Missing:")
for x in (x for x in file_new if not x.exists()):
print(x)
assert not all(x.exists() for x in src)
assert all(x.exists() for x in file_new)
@pytest.mark.parametrize("use_iter", [True, False])
def test_delete(self, file_seq_for_operation, use_iter):
src: FileSequence
dst: Path
src, dst = file_seq_for_operation
assert src.path.exists()
if use_iter:
for item in src.delete_iter():
print(f"deleted: {item}")
assert isinstance(item, Path)
assert not item.exists()
else:
src.delete()
assert len([x for x in src.path.parent.iterdir()]) == 0
print("--------")
print("Source Dir ls:")
for i, x in enumerate(src.path.parent.iterdir(), 1):
print(f"{i}: {x}")
@pytest.mark.parametrize("use_iter", [True, False])
def test_chmod(self, file_seq_for_operation, use_iter):
src: FileSequence
dst: Path
src, dst = file_seq_for_operation
original_mode = src.path.stat().st_mode
print("Original mode list:")
for x in src:
print(x.stat().st_mode, str(x))
print("--------")
if use_iter:
for item in src.chmod_iter(0o777):
print(f"changed: {item}")
assert isinstance(item, Path)
else:
src.chmod(0o777)
print("--------")
print("Changed mode list:")
for x in src:
print(stat.S_IMODE(x.stat().st_mode), str(x))
if not os.name == "nt":
for path in src:
assert path.stat().st_mode != original_mode
assert stat.S_IMODE(path.stat().st_mode) == 0o777