v0.0.5

Author: jet-logic

README.md

@@ -14,7 +14,7 @@ If you find this project helpful, consider supporting me:
 ## Features ✨
 
 - **Pattern-based renaming** 🧩 - Use regex substitutions to transform filenames
-- **Smart case conversion** 🔠 - Convert to lowercase (`--lower`) or uppercase (`--upper`)
+- **Case conversion**: lower, upper, title, swapcase, capitalize
 - **URL-safe names** 🌐 - Clean filenames for web use (`--urlsafe`)
 - **Precise file selection** 🎯:
   - Include/exclude files with `--includes`/`--excludes`
@@ -65,7 +65,7 @@ python -m renx [OPTIONS] [PATHS...]
 The substitution pattern uses this format:
 
 ```
-❗REGEX❗REPLACEMENT❗FLAGS
+❗search❗replace❗[flags]❗[flags]❗[flags]
 ```
 
 Where:
@@ -125,6 +125,21 @@ For example, with `-s '/foo/bar/i'`:
 3. Replacement = `bar`
 4. Flags = `i` (case-insensitive)
 
+Special flags:
+
+- `upper`, `lower`, `title`, `swapcase`, `capitalize` - Case transformations
+- `ext` - Apply to extension only
+- `stem` - Apply to filename stem only
+
+Examples:
+
+- `-s '/foo/bar/'` - Replace 'foo' with 'bar'
+- `-s '/\.jpg$/.png/'` - Change .jpg extensions to .png
+- `-s '/^/prefix_/'` - Add prefix to all names
+- `-s '/_/-/g'` - Replace all underscores with hyphens
+- `-s '/.*//upper/'` - Convert entire name to uppercase
+- `-s '/\..*$//lower/ext'` - Convert extension to lowercase
+
 ## Important Notes
 
 - The delimiter can be any character (but must not appear unescaped in the pattern)
@@ -173,3 +188,21 @@ For example, with `-s '/foo/bar/i'`:
    ```bash
    python -m renx --max-depth 2 /path/to/files
    ```
+
+## Multiple substitution
+
+When your downloaded files look like they were named by a cat walking on a keyboard 😉:
+
+```bash
+python -m renx \
+    -s '#(?:(YTS(?:.?\w+)|YIFY|GloDLS|RARBG|ExTrEmE))##ix' \
+    -s '!(1080p|720p|HDRip|x264|x265|BRRip|WEB-DL|BDRip|AAC|DTS)!!i' \
+    -s '!\[(|\w+)\]!\1!' \
+    -s '/[\._-]+/./' \
+    -s '/\.+/ /stem' \
+    -s /.+//ext/lower \
+    -s '/.+//stem/title' \
+    .
+# Before: "the.matrix.[1999].1080p.[YTS.AM].BRRip.x264-[GloDLS].ExTrEmE.mKV"
+# After: "The Matrix 1999.mkv" 🎬✨
+```

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "renx"
-version = "0.0.4"
+version = "0.0.5"
 description = "Advanced file renaming tool with regex and case transformation support"
 readme = "README.md"
 authors = [

renx/__main__.py

@@ -1,29 +1,75 @@
-from os.path import dirname, join
+import unicodedata, re
 from os import rename
+from os.path import dirname, join
+from os.path import splitext
 from .scantree import ScanTree
-import unicodedata
 
 
-def text_to_ascii(text: str):
+def asciify(text: str):
     """
     Converts a Unicode string to its closest ASCII equivalent by removing
     accent marks and other non-ASCII characters.
     """
     return "".join(c for c in unicodedata.normalize("NFD", text) if unicodedata.category(c) != "Mn")
 
 
+def slugify(value):
+    value = str(value)
+    value = asciify(value)
+    value = re.sub(r"[^a-zA-Z0-9_.+-]+", "_", value)
+    return value
+
+
+def clean(value):
+    value = str(value)
+    value = re.sub(r"\-+", "-", value).strip("-")
+    value = re.sub(r"_+", "_", value).strip("_")
+    return value
+
+
+def urlsafe(name, parent=None):
+    s = slugify(name)
+    if s != name or re.search(r"[_-]\.", s) or re.search(r"[_-]+", s):
+        assert slugify(s) == s
+        stem, ext = splitext(s)
+        return clean(stem) + ext
+    return name
+
+
 def split_subs(s: str):
     a = s[1:].split(s[0], 3)
     if len(a) > 1:
         search = a[0]
         replace = a[1]
+        extra = {}
         if not search:
             raise RuntimeError(f"Empty search pattern {s!r}")
         if len(a) > 2:
-            flags = a[2]
+            flags = None
+            for x in a[2:]:
+                if x in [
+                    "upper",
+                    "lower",
+                    "title",
+                    "swapcase",
+                    "expandtabs",
+                    "casefold",
+                    "capitalize",
+                    "asciify",
+                    "slugify",
+                    "urlsafe",
+                    "ext",
+                    "stem",
+                ]:
+                    if x not in ["ext", "stem"]:
+                        assert not replace
+                        pass
+                    extra[x] = True
+                else:
+                    flags = x
             if flags:
                 search = f"(?{flags}){search}"
-        return search, replace, {}
+        return search, replace, extra
     raise RuntimeError(f"Invalid pattern  {s!r}")
 
 
@@ -61,37 +107,65 @@ def start(self):
             _subs.append((lambda name, parent: name.upper()))
 
         if self.urlsafe:
-            from os.path import splitext
-
-            def slugify(value):
-                value = str(value)
-                value = text_to_ascii(value)
-                value = re.sub(r"[^a-zA-Z0-9_.+-]+", "_", value)
-                return value
-
-            def clean(value):
-                value = str(value)
-                value = re.sub(r"\-+", "-", value).strip("-")
-                value = re.sub(r"_+", "_", value).strip("_")
-                return value
-
-            def urlsafe(name, parent):
-                s = slugify(name)
-                if s != name or re.search(r"[_-]\.", s) or re.search(r"[_-]+", s):
-                    assert slugify(s) == s
-                    stem, ext = splitext(s)
-                    return clean(stem) + ext
-                return name
-
             _subs.append(urlsafe)
 
-        def _append(rex, rep, extra):
+        def _append(rex, rep: str, extra):
+            if extra:
+
+                def fn(name: str, parent):
+                    if extra.get("stem"):
+                        S, x = splitext(name)
+                        fin = lambda r: r + x
+                    elif extra.get("ext"):
+                        x, S = splitext(name)
+                        fin = lambda r: x + r
+                    else:
+                        S = name
+                        fin = lambda r: r
+
+                    # def fr():
+                    #     return rex.sub(rep, S)
+
+                    if extra.get("lower"):
+                        R = lambda m: m.group(0).lower()
+                    elif extra.get("upper"):
+                        R = lambda m: m.group(0).upper()
+                    elif extra.get("title"):
+                        R = lambda m: m.group(0).title()
+                    elif extra.get("swapcase"):
+                        R = lambda m: m.group(0).swapcase()
+                    elif extra.get("casefold"):
+                        R = lambda m: m.group(0).casefold()
+                    elif extra.get("capitalize"):
+                        R = lambda m: m.group(0).capitalize()
+                    elif extra.get("asciify"):
+                        R = lambda m: asciify(m.group(0))
+                    elif extra.get("urlsafe"):
+                        R = lambda m: urlsafe(m.group(0))
+                    elif extra.get("slugify"):
+                        R = lambda m: urlsafe(m.group(0))
+                    else:
+                        R = rep
+                    # return fin(fx(fr()))
+
+                    return fin(rex.sub(R, S))
+
+            else:
+
+                def fn(name, parent):
+                    return rex.sub(rep, name)
+
+            fn.regx = rex
+
             # print("REX", rex, rep)
-            _subs.append((lambda name, parent: rex.sub(rep, name)))
+            _subs.append(fn)
 
         for s in self.subs:
             search, replace, extra = split_subs(s)
-            rex = regex(search)
+            try:
+                rex = regex(search)
+            except Exception as e:
+                raise RuntimeError(f"Bad regexp {search!r}: {e}")
             _append(rex, replace, extra)
 
         self._subs = _subs
@@ -107,6 +181,7 @@ def process_entry(self, de):
         for fn in self._subs:
             v = fn(name2, parent)
             # print("PE_subs", de.path, name2, v)
+            # print("fn", getattr(fn, "regx", "?"))
             if v:
                 name2 = v
         # print("PE", de.path, [name1, name2])

renx/main.py

@@ -15,9 +15,7 @@ def __init__(self, *args: str, **kwargs):
         self.args = args
         self.kwargs = kwargs
 
-    def _add(
-        self, name: str, type_: type, argp: "argparse.ArgumentParser", that: "Any"
-    ) -> None:
+    def _add(self, name: str, type_: type, argp: "argparse.ArgumentParser", that: "Any") -> None:
         """Add argument to parser."""
         args = []
         kwargs = {**self.kwargs}
@@ -26,15 +24,12 @@ def _add(
         action = kwargs.get("action")
         const = kwargs.get("const")
         default = kwargs.get("default", INVALID)
+        # kind = type(default)
         # print(name, type_, that, "_add", action, flag_arg)
 
         if action is None:
             if const is not None:
-                kwargs["action"] = (
-                    "append_const"
-                    if type_ and issubclass(type_, list)
-                    else "store_const"
-                )
+                kwargs["action"] = "append_const" if type_ and issubclass(type_, list) else "store_const"
             elif type_ is None:
                 kwargs["action"] = "store"
             elif issubclass(type_, bool):
@@ -50,7 +45,7 @@ def _add(
                 else:
                     assert default is INVALID or default is False
                     kwargs["action"] = "store_true"
-            elif issubclass(type_, list):
+            elif issubclass(type_, list) or isinstance(default, list):
                 if "nargs" not in kwargs:
                     kwargs["action"] = "append"
                 if "default" not in kwargs:
@@ -76,9 +71,7 @@ def _add(
         else:
 
             def add_args(x: str) -> None:
-                args.append(
-                    x if x.startswith("-") else (f"--{x}" if len(x) > 1 else f"-{x}")
-                )
+                args.append(x if x.startswith("-") else (f"--{x}" if len(x) > 1 else f"-{x}"))
 
             for x in self.args:
                 if " " in x or "\t" in x:
@@ -128,9 +121,7 @@ def __getattr__(self, name: str) -> "Any":
         try:
             m = super().__getattr__
         except AttributeError:
-            raise AttributeError(
-                f"{self.__class__.__name__} has no attribute {name}"
-            ) from None
+            raise AttributeError(f"{self.__class__.__name__} has no attribute {name}") from None
         else:
             return m(name)
 
@@ -165,9 +156,7 @@ def add_arguments(self, argp: "argparse.ArgumentParser") -> None:
         for k, v, t in _arg_fields(self):
             v._add(k, t, argp, self)
 
-    def parse_arguments(
-        self, argp: "argparse.ArgumentParser", args: "Sequence[str]|None"
-    ) -> None:
+    def parse_arguments(self, argp: "argparse.ArgumentParser", args: "Sequence[str]|None") -> None:
         """Parse command line arguments."""
         sp = None
         for s, k in self.sub_args():