filefilter 0.2.3__tar.gz → 0.2.4__tar.gz

{filefilter-0.2.3/src/filefilter.egg-info → filefilter-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: filefilter
-Version: 0.2.3
+Version: 0.2.4
 Summary: Filter files in a directory tree based on configurable glob rules.
 Author-email: "Ioannis D (devcoons)" <support@devcoons.com>
 License-Expression: MIT
@@ -161,10 +161,10 @@ When scanning files, the library applies filters in this exact sequence:
    - If the file extension matches `exclude.extensions` → **excluded immediately**.  
    - This step is not overridden by include patterns.
 
-2️⃣ **Path excludes vs. override dirs (`include.odirs`)**  
+2️⃣ **Path excludes vs. override patterns (`include.odirs`, `include.ofiles`)**  
    - If the file path matches `exclude.files`, or its parent directory matches `exclude.dirs`, the file is a candidate for exclusion.  
    - **`include.dirs` and `include.files` do not override excludes** — they only gate inclusion later.  
-   - If a matching pattern in `include.odirs` is **more specific** than the best matching exclude pattern → the exclude is **ignored** for this file.  
+   - If a matching pattern in `include.odirs` or `include.ofiles` is **more specific** than the best matching exclude pattern → the exclude is **ignored** for this file.  
    - Otherwise → **excluded**.
 
    | Pattern | Relative specificity |
@@ -172,9 +172,11 @@ When scanning files, the library applies filters in this exact sequence:
    | `**` | very low (broad) |
    | `**/KLM/**` | higher |
    | `**/KLM/ABC/**` | highest |
+   | `**/test_*.py` vs `**/test_keep.py` | ofile wins (more specific) |
 
    > Use `include.dirs` for normal scoping (e.g. `**`, `src/**`).  
-   > Use `include.odirs` only for explicit exceptions to `exclude.dirs` / `exclude.files`.
+   > Use `include.odirs` for directory carve-outs under `exclude.dirs` / `exclude.files`.  
+   > Use `include.ofiles` for file carve-outs under `exclude.files` / `exclude.dirs`.
 
 3️⃣ **Include-file fast path**  
    - If the file matches any `include.files` pattern → **included immediately**,  
@@ -202,6 +204,7 @@ When scanning files, the library applies filters in this exact sequence:
     "include": {
       "dirs": [],
       "odirs": [],
+      "ofiles": [],
       "files": [],
       "extensions": []
     },
@@ -219,6 +222,7 @@ When scanning files, the library applies filters in this exact sequence:
 | `root_dir` | Base directory (absolute or relative). |
 | `filters.include.dirs` | Directory inclusion patterns for gating (must match when any include filters are set). Never overrides excludes. |
 | `filters.include.odirs` | Optional. Override directory patterns (defaults to `[]` when omitted). When more specific than a matching exclude, the exclude is ignored for that path. Also satisfies dir gating. |
+| `filters.include.ofiles` | Optional. Override file patterns (defaults to `[]` when omitted). When more specific than a matching exclude, the exclude is ignored for that path. Also satisfies file gating (does not skip extension whitelist). |
 | `filters.include.files` | File inclusion patterns (glob-like). Forces inclusion (skips extension whitelist) once path excludes are resolved. Does not override excludes. |
 | `filters.include.extensions` | Extension whitelist. |
 | `filters.exclude.*` | Same structure, but acts as exclusion filters. |
@@ -470,11 +474,43 @@ The same technique applies to other “exclude a path part, except one branch”
 
 ---
 
+###  Example 8 — Exclude file patterns, except specific files
+
+Exclude all `test_*.py` files, but keep `test_keep.py`:
+
+```json
+{
+  "root_dir": ".",
+  "filters": {
+    "include": {
+      "dirs": ["**"],
+      "ofiles": ["**/test_keep.py"],
+      "files": [],
+      "extensions": ["py"]
+    },
+    "exclude": {
+      "dirs": [],
+      "files": ["**/test_*.py"],
+      "extensions": []
+    }
+  }
+}
+```
+
+| File Path | Result | Reason |
+|------------|---------|--------|
+| `src/app.py` | ✅ | broad include + `.py` extension |
+| `src/test_foo.py` | ❌ | `**/test_*.py` exclude; no matching `ofiles` |
+| `src/test_keep.py` | ✅ | `**/test_keep.py` ofile beats `**/test_*.py` exclude |
+| `nested/test_keep.py` | ✅ | ofile exception works at any depth |
+
+---
+
 ## Summary of Behavior
 
 - `exclude.extensions` are always applied first (hard exclude).  
 - `include.dirs` and `include.files` **never** override path excludes — they only gate inclusion.  
-- Only `include.odirs` can override a matching exclude, and only when the odir pattern is **more specific**.  
+- Only `include.odirs` and `include.ofiles` can override a matching exclude, and only when the override pattern is **more specific**.  
 - A matching `include.files` pattern forces inclusion (skips extension whitelist), once path excludes are resolved.  
 - If any include filters exist, at least one must match (inclusion gating).  
 - Extensions act as a **final whitelist** when not bypassed by `include.files`.  

{filefilter-0.2.3 → filefilter-0.2.4}/README.md

@@ -128,10 +128,10 @@ When scanning files, the library applies filters in this exact sequence:
    - If the file extension matches `exclude.extensions` → **excluded immediately**.  
    - This step is not overridden by include patterns.
 
-2️⃣ **Path excludes vs. override dirs (`include.odirs`)**  
+2️⃣ **Path excludes vs. override patterns (`include.odirs`, `include.ofiles`)**  
    - If the file path matches `exclude.files`, or its parent directory matches `exclude.dirs`, the file is a candidate for exclusion.  
    - **`include.dirs` and `include.files` do not override excludes** — they only gate inclusion later.  
-   - If a matching pattern in `include.odirs` is **more specific** than the best matching exclude pattern → the exclude is **ignored** for this file.  
+   - If a matching pattern in `include.odirs` or `include.ofiles` is **more specific** than the best matching exclude pattern → the exclude is **ignored** for this file.  
    - Otherwise → **excluded**.
 
    | Pattern | Relative specificity |
@@ -139,9 +139,11 @@ When scanning files, the library applies filters in this exact sequence:
    | `**` | very low (broad) |
    | `**/KLM/**` | higher |
    | `**/KLM/ABC/**` | highest |
+   | `**/test_*.py` vs `**/test_keep.py` | ofile wins (more specific) |
 
    > Use `include.dirs` for normal scoping (e.g. `**`, `src/**`).  
-   > Use `include.odirs` only for explicit exceptions to `exclude.dirs` / `exclude.files`.
+   > Use `include.odirs` for directory carve-outs under `exclude.dirs` / `exclude.files`.  
+   > Use `include.ofiles` for file carve-outs under `exclude.files` / `exclude.dirs`.
 
 3️⃣ **Include-file fast path**  
    - If the file matches any `include.files` pattern → **included immediately**,  
@@ -169,6 +171,7 @@ When scanning files, the library applies filters in this exact sequence:
     "include": {
       "dirs": [],
       "odirs": [],
+      "ofiles": [],
       "files": [],
       "extensions": []
     },
@@ -186,6 +189,7 @@ When scanning files, the library applies filters in this exact sequence:
 | `root_dir` | Base directory (absolute or relative). |
 | `filters.include.dirs` | Directory inclusion patterns for gating (must match when any include filters are set). Never overrides excludes. |
 | `filters.include.odirs` | Optional. Override directory patterns (defaults to `[]` when omitted). When more specific than a matching exclude, the exclude is ignored for that path. Also satisfies dir gating. |
+| `filters.include.ofiles` | Optional. Override file patterns (defaults to `[]` when omitted). When more specific than a matching exclude, the exclude is ignored for that path. Also satisfies file gating (does not skip extension whitelist). |
 | `filters.include.files` | File inclusion patterns (glob-like). Forces inclusion (skips extension whitelist) once path excludes are resolved. Does not override excludes. |
 | `filters.include.extensions` | Extension whitelist. |
 | `filters.exclude.*` | Same structure, but acts as exclusion filters. |
@@ -437,11 +441,43 @@ The same technique applies to other “exclude a path part, except one branch”
 
 ---
 
+###  Example 8 — Exclude file patterns, except specific files
+
+Exclude all `test_*.py` files, but keep `test_keep.py`:
+
+```json
+{
+  "root_dir": ".",
+  "filters": {
+    "include": {
+      "dirs": ["**"],
+      "ofiles": ["**/test_keep.py"],
+      "files": [],
+      "extensions": ["py"]
+    },
+    "exclude": {
+      "dirs": [],
+      "files": ["**/test_*.py"],
+      "extensions": []
+    }
+  }
+}
+```
+
+| File Path | Result | Reason |
+|------------|---------|--------|
+| `src/app.py` | ✅ | broad include + `.py` extension |
+| `src/test_foo.py` | ❌ | `**/test_*.py` exclude; no matching `ofiles` |
+| `src/test_keep.py` | ✅ | `**/test_keep.py` ofile beats `**/test_*.py` exclude |
+| `nested/test_keep.py` | ✅ | ofile exception works at any depth |
+
+---
+
 ## Summary of Behavior
 
 - `exclude.extensions` are always applied first (hard exclude).  
 - `include.dirs` and `include.files` **never** override path excludes — they only gate inclusion.  
-- Only `include.odirs` can override a matching exclude, and only when the odir pattern is **more specific**.  
+- Only `include.odirs` and `include.ofiles` can override a matching exclude, and only when the override pattern is **more specific**.  
 - A matching `include.files` pattern forces inclusion (skips extension whitelist), once path excludes are resolved.  
 - If any include filters exist, at least one must match (inclusion gating).  
 - Extensions act as a **final whitelist** when not bypassed by `include.files`.  

{filefilter-0.2.3 → filefilter-0.2.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "filefilter"
-version = "0.2.3"
+version = "0.2.4"
 description = "Filter files in a directory tree based on configurable glob rules."
 readme = "README.md"
 authors = [{ name = "Ioannis D (devcoons)", email = "support@devcoons.com" }]

{filefilter-0.2.3 → filefilter-0.2.4}/src/filefilter/__init__.py

@@ -24,7 +24,7 @@
 #                                                                                       #
 #########################################################################################
 
-__version__ = '0.2.3'
+__version__ = '0.2.4'
 
 #########################################################################################
 # IMPORTS                                                                               #

{filefilter-0.2.3 → filefilter-0.2.4}/src/filefilter/collector.py

@@ -168,6 +168,9 @@ def should_include(full_path: str, cfg: Ruleset) -> bool:
     gate_dirs = _merge(inc_dirs, odirs)
 
     odir_spec = best_matching_specificity(odirs, match_dir, dir_rel)
+    ofiles = cfg.include_ofiles or []
+    ofile_spec = best_matching_specificity(ofiles, match_file, rel)
+    override_spec = max(odir_spec, ofile_spec)
 
     exc_dirs = _merge(cfg.exc_dirs_root, cfg.exc_dirs_one, cfg.exc_dirs_any)
     exc_path_spec = -1
@@ -184,13 +187,14 @@ def should_include(full_path: str, cfg: Ruleset) -> bool:
             exc_path_spec,
             best_matching_specificity(exc_dirs, match_dir, dir_rel),
         )
-    if exclude_path_hit and odir_spec <= exc_path_spec:
+    if exclude_path_hit and override_spec <= exc_path_spec:
         return False
 
-    files_present = bool(cfg.include_files)
-    files_match = files_present and match_file(rel, cfg.include_files)
-    if files_match:
+    gate_files = _merge(cfg.include_files, ofiles)
+    if cfg.include_files and match_file(rel, cfg.include_files):
         return True
+    files_present = bool(gate_files)
+    files_match = files_present and match_file(rel, gate_files)
     dirs_present = bool(gate_dirs)
     dirs_match = dirs_present and match_dir(dir_rel, gate_dirs)
     if (files_present or dirs_present) and not (files_match or dirs_match):

{filefilter-0.2.3 → filefilter-0.2.4}/src/filefilter/ruleset.py

@@ -58,6 +58,7 @@ class Ruleset:
         self.exc_dirs_root, self.exc_dirs_one, self.exc_dirs_any = parse_dir_patterns(exc.get('dirs', []))
 
         self.include_files = parse_file_patterns(inc.get('files', []))
+        self.include_ofiles = parse_file_patterns(inc.get('ofiles', []))
         self.exclude_files = parse_file_patterns(exc.get('files', []))
 
         self.inc_exts = parse_extensions(inc.get('extensions', []))

{filefilter-0.2.3 → filefilter-0.2.4/src/filefilter.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: filefilter
-Version: 0.2.3
+Version: 0.2.4
 Summary: Filter files in a directory tree based on configurable glob rules.
 Author-email: "Ioannis D (devcoons)" <support@devcoons.com>
 License-Expression: MIT
@@ -161,10 +161,10 @@ When scanning files, the library applies filters in this exact sequence:
    - If the file extension matches `exclude.extensions` → **excluded immediately**.  
    - This step is not overridden by include patterns.
 
-2️⃣ **Path excludes vs. override dirs (`include.odirs`)**  
+2️⃣ **Path excludes vs. override patterns (`include.odirs`, `include.ofiles`)**  
    - If the file path matches `exclude.files`, or its parent directory matches `exclude.dirs`, the file is a candidate for exclusion.  
    - **`include.dirs` and `include.files` do not override excludes** — they only gate inclusion later.  
-   - If a matching pattern in `include.odirs` is **more specific** than the best matching exclude pattern → the exclude is **ignored** for this file.  
+   - If a matching pattern in `include.odirs` or `include.ofiles` is **more specific** than the best matching exclude pattern → the exclude is **ignored** for this file.  
    - Otherwise → **excluded**.
 
    | Pattern | Relative specificity |
@@ -172,9 +172,11 @@ When scanning files, the library applies filters in this exact sequence:
    | `**` | very low (broad) |
    | `**/KLM/**` | higher |
    | `**/KLM/ABC/**` | highest |
+   | `**/test_*.py` vs `**/test_keep.py` | ofile wins (more specific) |
 
    > Use `include.dirs` for normal scoping (e.g. `**`, `src/**`).  
-   > Use `include.odirs` only for explicit exceptions to `exclude.dirs` / `exclude.files`.
+   > Use `include.odirs` for directory carve-outs under `exclude.dirs` / `exclude.files`.  
+   > Use `include.ofiles` for file carve-outs under `exclude.files` / `exclude.dirs`.
 
 3️⃣ **Include-file fast path**  
    - If the file matches any `include.files` pattern → **included immediately**,  
@@ -202,6 +204,7 @@ When scanning files, the library applies filters in this exact sequence:
     "include": {
       "dirs": [],
       "odirs": [],
+      "ofiles": [],
       "files": [],
       "extensions": []
     },
@@ -219,6 +222,7 @@ When scanning files, the library applies filters in this exact sequence:
 | `root_dir` | Base directory (absolute or relative). |
 | `filters.include.dirs` | Directory inclusion patterns for gating (must match when any include filters are set). Never overrides excludes. |
 | `filters.include.odirs` | Optional. Override directory patterns (defaults to `[]` when omitted). When more specific than a matching exclude, the exclude is ignored for that path. Also satisfies dir gating. |
+| `filters.include.ofiles` | Optional. Override file patterns (defaults to `[]` when omitted). When more specific than a matching exclude, the exclude is ignored for that path. Also satisfies file gating (does not skip extension whitelist). |
 | `filters.include.files` | File inclusion patterns (glob-like). Forces inclusion (skips extension whitelist) once path excludes are resolved. Does not override excludes. |
 | `filters.include.extensions` | Extension whitelist. |
 | `filters.exclude.*` | Same structure, but acts as exclusion filters. |
@@ -470,11 +474,43 @@ The same technique applies to other “exclude a path part, except one branch”
 
 ---
 
+###  Example 8 — Exclude file patterns, except specific files
+
+Exclude all `test_*.py` files, but keep `test_keep.py`:
+
+```json
+{
+  "root_dir": ".",
+  "filters": {
+    "include": {
+      "dirs": ["**"],
+      "ofiles": ["**/test_keep.py"],
+      "files": [],
+      "extensions": ["py"]
+    },
+    "exclude": {
+      "dirs": [],
+      "files": ["**/test_*.py"],
+      "extensions": []
+    }
+  }
+}
+```
+
+| File Path | Result | Reason |
+|------------|---------|--------|
+| `src/app.py` | ✅ | broad include + `.py` extension |
+| `src/test_foo.py` | ❌ | `**/test_*.py` exclude; no matching `ofiles` |
+| `src/test_keep.py` | ✅ | `**/test_keep.py` ofile beats `**/test_*.py` exclude |
+| `nested/test_keep.py` | ✅ | ofile exception works at any depth |
+
+---
+
 ## Summary of Behavior
 
 - `exclude.extensions` are always applied first (hard exclude).  
 - `include.dirs` and `include.files` **never** override path excludes — they only gate inclusion.  
-- Only `include.odirs` can override a matching exclude, and only when the odir pattern is **more specific**.  
+- Only `include.odirs` and `include.ofiles` can override a matching exclude, and only when the override pattern is **more specific**.  
 - A matching `include.files` pattern forces inclusion (skips extension whitelist), once path excludes are resolved.  
 - If any include filters exist, at least one must match (inclusion gating).  
 - Extensions act as a **final whitelist** when not bypassed by `include.files`.  

{filefilter-0.2.3 → filefilter-0.2.4}/tests/test_inclusion_logic.py

@@ -250,3 +250,65 @@ def test_abc_klm_exception_via_include_odirs(tmp_path: Path):
     assert str(tmp_path / "src" / "ABC" / "KLM" / "nested" / "keep.c") in paths
     assert str(tmp_path / "src" / "x" / "ABC" / "other" / "skip.c") not in paths
     assert str(tmp_path / "src" / "x" / "ABC" / "KLM" / "keep.c") in paths
+
+
+def test_specific_ofile_beats_broader_exclude_file(tmp_path: Path):
+    """Only include.ofiles override excludes; include.files do not."""
+    touch(tmp_path / "src" / "app.py")
+    touch(tmp_path / "src" / "test_foo.py")
+    touch(tmp_path / "src" / "test_keep.py")
+    touch(tmp_path / "src" / "nested" / "test_keep.py")
+
+    cfg = make_config(
+        include_dirs=["**"],
+        include_ofiles=["**/test_keep.py"],
+        include_extensions=["py"],
+        exclude_files=["**/test_*.py"],
+    )
+    paths = select_paths(tmp_path, cfg)
+
+    assert str(tmp_path / "src" / "app.py") in paths
+    assert str(tmp_path / "src" / "test_foo.py") not in paths
+    assert str(tmp_path / "src" / "test_keep.py") in paths
+    assert str(tmp_path / "src" / "nested" / "test_keep.py") in paths
+
+
+def test_include_files_do_not_override_exclude_file(tmp_path: Path):
+    touch(tmp_path / "src" / "test_keep.py")
+    cfg = make_config(
+        include_dirs=["**"],
+        include_files=["**/test_keep.py", "**/test_*.py"],
+        include_extensions=["py"],
+        exclude_files=["**/test_*.py"],
+    )
+    paths = select_paths(tmp_path, cfg)
+    assert str(tmp_path / "src" / "test_keep.py") not in paths
+
+
+def test_ofile_overrides_exclude_dir_for_single_file(tmp_path: Path):
+    touch(tmp_path / "build" / "app.py")
+    touch(tmp_path / "build" / "keep.py")
+    cfg = make_config(
+        include_dirs=["**"],
+        include_ofiles=["**/build/keep.py"],
+        include_extensions=["py"],
+        exclude_dirs=["**/build/**"],
+    )
+    paths = select_paths(tmp_path, cfg)
+    assert str(tmp_path / "build" / "app.py") not in paths
+    assert str(tmp_path / "build" / "keep.py") in paths
+
+
+def test_ofile_satisfies_file_gating_without_fast_path(tmp_path: Path):
+    """ofiles satisfy gating but do not skip extension whitelist."""
+    touch(tmp_path / "src" / "keep.txt")
+    touch(tmp_path / "src" / "skip.txt")
+    cfg = make_config(
+        include_files=["**/only.py"],
+        include_ofiles=["**/keep.txt"],
+        include_extensions=["py"],
+        exclude_files=["**/*.txt"],
+    )
+    paths = select_paths(tmp_path, cfg)
+    assert str(tmp_path / "src" / "keep.txt") not in paths
+    assert str(tmp_path / "src" / "skip.txt") not in paths

{filefilter-0.2.3 → filefilter-0.2.4}/tests/test_ruleset.py

@@ -86,6 +86,35 @@ def test_parse_odirs_buckets_like_dirs():
     assert rules.inc_odirs_one == ["*/pkg"]
 
 
+def test_missing_ofiles_defaults_to_empty(tmp_path: Path):
+    cfg = {
+        "root_dir": ".",
+        "filters": {
+            "include": {"dirs": ["**"], "extensions": ["py"]},
+            "exclude": {"files": ["**/skip.py"]},
+        },
+    }
+    touch(tmp_path / "app.py")
+    touch(tmp_path / "skip.py")
+    rules = load(json.dumps(cfg), base=str(tmp_path))
+    assert rules.include_ofiles == []
+    assert matches(str(tmp_path / "app.py"), rules) is True
+    assert matches(str(tmp_path / "skip.py"), rules) is False
+
+
+def test_parse_ofiles_like_files():
+    cfg = {
+        "root_dir": ".",
+        "filters": {
+            "include": {"files": ["*.py"], "ofiles": ["**/keep.txt", "README.*"]},
+            "exclude": {},
+        },
+    }
+    rules = Ruleset(cfg, resolve_base=".")
+    assert rules.include_files == ["*.py"]
+    assert rules.include_ofiles == ["**/keep.txt", "readme.*"]
+
+
 def test_empty_dir_patterns_are_ignored(tmp_path: Path):
     cfg = {
         "root_dir": ".",