ruff-sync 0.1.6.dev2__py3-none-any.whl → 0.1.6.dev4__py3-none-any.whl

ruff_sync/cli.py

@@ -31,7 +31,9 @@ from ruff_sync.constants import (
     DEFAULT_BRANCH,
     DEFAULT_EXCLUDE,
     DEFAULT_PATH,
+    MISSING,
     ConfKey,
+    MissingType,
     OutputFormat,
 )
 from ruff_sync.core import (
@@ -105,11 +107,11 @@ class Arguments(NamedTuple):
     semantic: bool = False
     diff: bool = True
     init: bool = False
-    pre_commit: bool = False
+    pre_commit: bool | MissingType = MISSING
     save: bool | None = None
     output_format: OutputFormat = OutputFormat.TEXT
-    validate: bool = False  # run --validate checks before writing
-    strict: bool = False  # treat warnings as errors (implies --validate)
+    validate: bool | MissingType = MISSING  # run --validate checks before writing
+    strict: bool | MissingType = MISSING  # treat warnings as errors (implies --validate)
 
     @property
     @deprecated("Use 'to' instead")
@@ -123,6 +125,53 @@ class Arguments(NamedTuple):
         """Return the set of all field names, including deprecated ones."""
         return set(cls._fields) | {"source"}
 
+    def resolve(self) -> ExecutionArgs:
+        """Resolve all MISSING sentinels to their effective defaults for execution."""
+        from ruff_sync.constants import resolve_bool_flags  # noqa: PLC0415
+
+        eff_validate, eff_strict, eff_pre_commit = resolve_bool_flags(
+            self.validate,
+            self.strict,
+            self.pre_commit,
+        )
+        return ExecutionArgs(
+            command=self.command,
+            upstream=self.upstream,
+            to=self.to,
+            exclude=self.exclude,
+            verbose=self.verbose,
+            branch=self.branch,
+            path=self.path,
+            semantic=self.semantic,
+            diff=self.diff,
+            init=self.init,
+            pre_commit=eff_pre_commit,
+            save=self.save,
+            output_format=self.output_format,
+            validate=eff_validate,
+            strict=eff_strict,
+        )
+
+
+class ExecutionArgs(NamedTuple):
+    """Resolved arguments for execution logic — all sentinels replaced with concrete values."""
+
+    command: str
+    upstream: tuple[URL, ...]
+    to: pathlib.Path
+    exclude: Iterable[str]
+    verbose: int
+    branch: str
+    path: str | None
+    semantic: bool
+    diff: bool
+    init: bool
+    pre_commit: bool  # plain bool — MISSING resolved to default
+    save: bool | None
+    output_format: OutputFormat
+    validate: bool  # plain bool — MISSING resolved to default
+    strict: bool  # plain bool — MISSING resolved to default
+
 
 class ResolvedArgs(NamedTuple):
     """Internal container for resolved arguments."""
@@ -153,8 +202,8 @@ class CLIArguments(Protocol):
     save: bool | None
     semantic: bool
     diff: bool
-    validate: bool
-    strict: bool
+    validate: bool | None
+    strict: bool | None
 
 
 @lru_cache(maxsize=1)
@@ -294,6 +343,24 @@ def _get_cli_parser() -> ArgumentParser:
         default=None,
         help="Format for output. Default: text (auto-detected in CI).",
     )
+    common_parser.add_argument(
+        "--validate",
+        action=BooleanOptionalAction,
+        default=None,
+        help=(
+            "Validate the merged config with Ruff before writing to disk. "
+            "Aborts if Ruff rejects the config. Off by default."
+        ),
+    )
+    common_parser.add_argument(
+        "--strict",
+        action=BooleanOptionalAction,
+        default=None,
+        help=(
+            "Treat all validation warnings as hard failures. Implies --validate. "
+            "Aborts if any version mismatch or deprecated rule is detected."
+        ),
+    )
 
     # Pull subcommand (the default action)
     pull_parser = subparsers.add_parser(
@@ -312,24 +379,6 @@ def _get_cli_parser() -> ArgumentParser:
         default=None,
         help="Save CLI arguments to [tool.ruff-sync] in pyproject.toml.",
     )
-    pull_parser.add_argument(
-        "--validate",
-        action="store_true",
-        default=False,
-        help=(
-            "Validate the merged config with Ruff before writing to disk. "
-            "Aborts if Ruff rejects the config. Off by default."
-        ),
-    )
-    pull_parser.add_argument(
-        "--strict",
-        action="store_true",
-        default=False,
-        help=(
-            "Treat all validation warnings as hard failures. Implies --validate. "
-            "Aborts if any version mismatch or deprecated rule is detected."
-        ),
-    )
 
     # Check subcommand
     check_parser = subparsers.add_parser(
@@ -500,6 +549,44 @@ def _resolve_to(args: CLIArguments, config: Config, initial_to: pathlib.Path) ->
     return initial_to
 
 
+def _resolve_validate(args: CLIArguments, config: Config) -> bool | MissingType:
+    """Resolve validation setting from CLI or config.
+
+    If ``--strict`` was explicitly set at the CLI level, it implies ``--validate``.
+    This prevents ``validate = false`` in config from silently neutralising a
+    CLI ``--strict`` flag.
+    """
+    # CLI --validate flag wins if explicitly provided
+    if args.validate is not None:
+        return args.validate
+
+    # If --strict was explicitly passed via CLI, it implies validate=True
+    # even when config sets `validate = false`.
+    if args.strict is True:
+        return True
+
+    # Fallback to config
+    validate_attr = ConfKey.to_attr(ConfKey.VALIDATE)
+    if validate_attr in config:
+        return bool(config[validate_attr])  # type: ignore[literal-required]
+
+    return MISSING
+
+
+def _resolve_strict(args: CLIArguments, config: Config) -> bool | MissingType:
+    """Resolve strict setting from CLI or config."""
+    # CLI flag --strict always wins
+    if args.strict is not None:
+        return args.strict
+
+    # Fallback to config
+    attr = ConfKey.to_attr(ConfKey.STRICT)
+    if attr in config:
+        return bool(config[attr])  # type: ignore[literal-required]
+
+    return MISSING
+
+
 def _resolve_args(args: CLIArguments, config: Config, initial_to: pathlib.Path) -> ResolvedArgs:
     """Resolve upstream, to, exclude, branch, and path from CLI and config."""
     upstream = _resolve_upstream(args, config)
@@ -522,7 +609,7 @@ def _resolve_args(args: CLIArguments, config: Config, initial_to: pathlib.Path)
     )
 
 
-def _resolve_pre_commit(args: CLIArguments, config: Config) -> bool:
+def _resolve_pre_commit(args: CLIArguments, config: Config) -> bool | MissingType:
     """Resolve pre-commit sync setting from CLI or config."""
     if args.pre_commit is not None:
         return args.pre_commit
@@ -531,7 +618,7 @@ def _resolve_pre_commit(args: CLIArguments, config: Config) -> bool:
     if pre_commit_attr in config:
         val = config.get(pre_commit_attr)
         return bool(val)
-    return False
+    return MISSING
 
 
 def _detect_ci_provider() -> CIProvider | None:
@@ -599,28 +686,35 @@ def main() -> int:
     initial_to = pathlib.Path(arg_to) if arg_to else pathlib.Path()
     config: Config = get_config(initial_to)
 
-    upstream, to_val, exclude, branch, path, output_format = _resolve_args(args, config, initial_to)
-    pre_commit_val = _resolve_pre_commit(args, config)
+    # Resolve all arguments (honoring CLI overrides over config values)
+    resolved = _resolve_args(args, config, initial_to)
+
+    resolved_upstream = tuple(
+        resolve_raw_url(u, branch=resolved.branch, path=resolved.path) for u in resolved.upstream
+    )
 
-    resolved_upstream = tuple(resolve_raw_url(u, branch=branch, path=path) for u in upstream)
+    # Resolve validation flags from CLI (with CLI --strict implying validate=True)
+    # and fall back to config. Bidirectional implications are handled by
+    # resolve_bool_flags() inside Arguments.resolve(), so we store raw sentinels here.
+    raw_validate = _resolve_validate(args, config)
+    raw_strict = _resolve_strict(args, config)
 
     exec_args = Arguments(
         command=args.command,
         upstream=resolved_upstream,
-        to=to_val,
-        exclude=exclude,
+        to=resolved.to,
+        exclude=resolved.exclude,
         verbose=args.verbose,
-        branch=branch,
-        path=path,
+        branch=resolved.branch,
+        path=resolved.path,
         semantic=getattr(args, "semantic", False),
         diff=getattr(args, "diff", True),
         init=getattr(args, "init", False),
-        pre_commit=pre_commit_val,
+        pre_commit=_resolve_pre_commit(args, config),
         save=getattr(args, "save", None),
-        output_format=output_format,
-        # --strict implies --validate
-        validate=getattr(args, "validate", False) or getattr(args, "strict", False),
-        strict=getattr(args, "strict", False),
+        output_format=resolved.output_format,
+        validate=raw_validate,
+        strict=raw_strict,
     )
 
     # Warn if the specified output format doesn't match the current CI environment

ruff_sync/constants.py

@@ -81,6 +81,8 @@ class ConfKey(str, enum.Enum):
     INIT = "init"
     SAVE = "save"
     VERBOSE = "verbose"
+    VALIDATE = "validate"
+    STRICT = "strict"
 
     # Legacy / Alias Keys
     SOURCE = "source"  # Legacy for 'to'
@@ -127,13 +129,13 @@ class ConfKey(str, enum.Enum):
 
 def resolve_defaults(
     branch: str | MissingType,
-    path: str | MissingType,
+    path: str | None | MissingType,
     exclude: Iterable[str] | MissingType,
 ) -> tuple[str, str | None, Iterable[str]]:
     """Resolve MISSING sentinel values to their effective defaults.
 
-    This is the single source of truth for MISSING → default resolution across
-    the CLI and internal logic, keeping the layers in sync.
+    This is the single source of truth for MISSING → default resolution for
+    URL-related parameters (branch, path, exclude).
 
     Args:
         branch: The resolved branch value or ``MISSING``.
@@ -151,4 +153,40 @@ def resolve_defaults(
     # but explicit None is the canonical "root directory" sentinel.
     eff_path: str | None = raw_path or None
     eff_exclude = exclude if exclude is not MISSING else DEFAULT_EXCLUDE
+
     return eff_branch, eff_path, eff_exclude
+
+
+def apply_bool_precedence(
+    validate: bool | MissingType, strict: bool | MissingType
+) -> tuple[bool | MissingType, bool | MissingType]:
+    """Apply precedence rules for validate and strict flags.
+
+    1. Disabling validation implicitly disables strict mode.
+    2. Strict mode implicitly enables validation.
+    """
+    if validate is False:
+        strict = False
+    elif strict is True:
+        validate = True
+    return validate, strict
+
+
+def resolve_bool_flags(
+    validate: bool | MissingType = MISSING,
+    strict: bool | MissingType = MISSING,
+    pre_commit: bool | MissingType = MISSING,
+) -> tuple[bool, bool, bool]:
+    """Resolve MISSING sentinel values for boolean execution flags.
+
+    Returns:
+        A ``(validate, strict, pre_commit)`` tuple with defaults applied.
+        ``strict=True`` implicitly enables ``validate``.
+    """
+    validate, strict = apply_bool_precedence(validate, strict)
+
+    eff_validate = validate if validate is not MISSING else False
+    eff_strict = strict if strict is not MISSING else False
+    eff_pre_commit = pre_commit if pre_commit is not MISSING else False
+
+    return eff_validate, eff_strict, eff_pre_commit

ruff_sync/core.py

@@ -34,6 +34,7 @@ from ruff_sync.constants import (
     DEFAULT_BRANCH,
     DEFAULT_EXCLUDE,
     DEFAULT_PATH,
+    MISSING,
     ConfKey,
 )
 from ruff_sync.formatters import ResultFormatter, get_formatter
@@ -42,7 +43,7 @@ from ruff_sync.pre_commit import sync_pre_commit
 if TYPE_CHECKING:
     from tomlkit.container import Container
 
-    from ruff_sync.cli import Arguments
+    from ruff_sync.cli import Arguments, ExecutionArgs
 
 __all__: Final[list[str]] = [
     "Config",
@@ -123,6 +124,8 @@ class Config(TypedDict, total=False):
     init: bool
     pre_commit_version_sync: bool
     output_format: str
+    validate: bool
+    strict: bool
 
 
 def _resolve_upstream_target_path(path: str | None) -> str:
@@ -743,7 +746,7 @@ async def fetch_upstreams_concurrently(
 async def _merge_multiple_upstreams(
     target_doc: TOMLDocument,
     is_target_ruff_toml: bool,
-    args: Arguments,
+    args: ExecutionArgs,
     client: httpx.AsyncClient,
 ) -> TOMLDocument:
     """Fetch and merge all upstreams into the target document.
@@ -751,10 +754,8 @@ async def _merge_multiple_upstreams(
     Downloads are performed concurrently via fetch_upstreams_concurrently,
     while merging remains sequential to preserve layering order.
     """
-    branch, path, exclude = args.branch, args.path, args.exclude
-
     fetch_results = await fetch_upstreams_concurrently(
-        args.upstream, client, branch=branch, path=path
+        args.upstream, client, branch=args.branch, path=args.path
     )
 
     # Sequentially merge the results in the original order
@@ -767,7 +768,7 @@ async def _merge_multiple_upstreams(
             fetch_result.buffer.read(),
             is_ruff_toml=is_upstream_ruff_toml,
             create_if_missing=False,
-            exclude=exclude,
+            exclude=args.exclude,
         )
 
         target_doc = merge_ruff_toml(
@@ -804,14 +805,14 @@ def _print_diff(
     fmt.diff("".join(diff))
 
 
-def _check_pre_commit_sync(args: Arguments, fmt: ResultFormatter) -> int | None:
+def _check_pre_commit_sync(pre_commit: bool, fmt: ResultFormatter) -> int | None:
     """Return exit code 3 if pre-commit hook version is out of sync, otherwise None.
 
     Shared helper to avoid duplicating the pre-commit synchronization logic.
     Exit code 3 is reserved for pre-commit hook drift to avoid collision with
     argparse (2) and config drift (1).
     """
-    if getattr(args, "pre_commit", False) and not sync_pre_commit(pathlib.Path.cwd(), dry_run=True):
+    if pre_commit and not sync_pre_commit(pathlib.Path.cwd(), dry_run=True):
         repo_root = pathlib.Path.cwd()
         pre_commit_config = repo_root / ".pre-commit-config.yaml"
         file_path = pre_commit_config if pre_commit_config.exists() else repo_root
@@ -944,6 +945,9 @@ async def check(
         ... )
         >>> # asyncio.run(check(args))
     """
+    # Resolve defaults for execution logic
+    exec_args = args.resolve()
+
     output_format = args.output_format
     fmt: ResultFormatter = get_formatter(output_format)
     try:
@@ -970,7 +974,7 @@ async def check(
             merged_doc = await _merge_multiple_upstreams(
                 merged_doc,
                 is_target_ruff_toml=is_ruff_toml_file(_source_toml_path.name),
-                args=args,
+                args=exec_args,
                 client=client,
             )
 
@@ -991,13 +995,13 @@ async def check(
 
             if source_val == merged_val:
                 fmt.success("✅ Ruff configuration is semantically in sync.")
-                exit_code = _check_pre_commit_sync(args, fmt)
+                exit_code = _check_pre_commit_sync(exec_args.pre_commit, fmt)
                 if exit_code is not None:
                     return exit_code
                 return 0
         elif source_doc.as_string() == merged_doc.as_string():
             fmt.success("✅ Ruff configuration is in sync.")
-            exit_code = _check_pre_commit_sync(args, fmt)
+            exit_code = _check_pre_commit_sync(exec_args.pre_commit, fmt)
             if exit_code is not None:
                 return exit_code
             return 0
@@ -1096,8 +1100,15 @@ def serialize_ruff_sync_config(doc: TOMLDocument, args: Arguments) -> None:
     if args.path != DEFAULT_PATH and args.path is not None:
         ruff_sync_table[ConfKey.PATH] = args.path
 
-    if args.pre_commit:
-        ruff_sync_table[ConfKey.PRE_COMMIT_VERSION_SYNC] = args.pre_commit
+    # Simple boolean flags
+    for key, attr in [
+        (ConfKey.PRE_COMMIT_VERSION_SYNC, "pre_commit"),
+        (ConfKey.VALIDATE, "validate"),
+        (ConfKey.STRICT, "strict"),
+    ]:
+        val = getattr(args, attr, MISSING)
+        if val is not MISSING:
+            ruff_sync_table[key] = val
 
 
 async def pull(
@@ -1122,6 +1133,9 @@ async def pull(
         ... )
         >>> # asyncio.run(pull(args))
     """
+    # Resolve defaults for execution logic
+    exec_args = args.resolve()
+
     output_format = args.output_format
     fmt = get_formatter(output_format)
     try:
@@ -1154,17 +1168,20 @@ async def pull(
             source_doc = await _merge_multiple_upstreams(
                 source_doc,
                 is_target_ruff_toml=is_ruff_toml_file(_source_toml_path.name),
-                args=args,
+                args=exec_args,
                 client=client,
             )
 
         # Validation is opt-in — only run if --validate (or --strict) was passed
-        if args.validate:
+        if exec_args.validate:
             from ruff_sync.validation import validate_merged_config  # noqa: PLC0415
 
             is_ruff_toml = is_ruff_toml_file(_source_toml_path.name)
             if not validate_merged_config(
-                source_doc, is_ruff_toml=is_ruff_toml, strict=args.strict, exclude=args.exclude
+                source_doc,
+                is_ruff_toml=is_ruff_toml,
+                strict=exec_args.strict,
+                exclude=exec_args.exclude,
             ):
                 fmt.error(
                     "❌ Merged config failed validation. Local file left unchanged.",
@@ -1190,7 +1207,7 @@ async def pull(
             rel_path = _source_toml_path.resolve()
         fmt.success(f"✅ Updated {rel_path}")
 
-        if args.pre_commit:
+        if exec_args.pre_commit:
             sync_pre_commit(pathlib.Path.cwd(), dry_run=False)
 
         return 0

ruff_sync/validation.py

@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+import functools
+import json
 import logging
 import pathlib
 import re
@@ -109,6 +111,97 @@ def check_python_version_consistency(
     return True
 
 
+_RULE_LIST_KEYS: frozenset[str] = frozenset({"select", "extend-select", "ignore", "extend-ignore"})
+
+
+@functools.lru_cache(maxsize=1)
+def _get_deprecated_rule_codes() -> frozenset[str]:
+    """Return the set of deprecated rule codes reported by the installed Ruff version.
+
+    Returns an empty frozenset if ruff is not found or output cannot be parsed.
+    """
+    try:
+        result = subprocess.run(
+            ["ruff", "rule", "--all", "--output-format", "json"],  # noqa: S607
+            capture_output=True,
+            text=True,
+            timeout=30,
+            check=False,
+        )
+        if result.returncode != 0:
+            return frozenset()
+        rules = json.loads(result.stdout)
+        return frozenset(r["code"] for r in rules if r.get("deprecated") is True)
+    except (
+        FileNotFoundError,
+        subprocess.TimeoutExpired,
+        json.JSONDecodeError,
+        KeyError,
+        TypeError,
+    ):
+        return frozenset()
+
+
+def check_deprecated_rules(
+    doc: TOMLDocument,
+    is_ruff_toml: bool = False,
+    strict: bool = False,
+    _deprecated_codes: frozenset[str] | None = None,
+    exclude: Iterable[str] = (),
+) -> bool:
+    """Warn if the merged config references any deprecated Ruff rules.
+
+    Args:
+        doc: The merged TOML document.
+        is_ruff_toml: True if the document is a standalone ruff.toml.
+        strict: If True, treat deprecated rules as a failure.
+        _deprecated_codes: Optional set of deprecated codes to use (for testing).
+        exclude: List of keys excluded from the ruff configuration.
+
+    Returns:
+        True if no deprecated rules are found, or if strict=False.
+        False if strict=True and deprecated rules are found.
+    """
+    deprecated_codes = (
+        _deprecated_codes if _deprecated_codes is not None else _get_deprecated_rule_codes()
+    )
+    if not deprecated_codes:
+        return True  # Nothing to check (ruff not found or returned no deprecated rules)
+
+    if is_ruff_toml:
+        lint_section = doc.get("lint", {})
+    else:
+        lint_section = doc.get("tool", {}).get("ruff", {}).get("lint", {})
+
+    if not isinstance(lint_section, dict):
+        return True
+
+    found_deprecated = False
+    for key in _RULE_LIST_KEYS:
+        full_key = f"lint.{key}" if is_ruff_toml else f"tool.ruff.lint.{key}"
+        if key in exclude or full_key in exclude:
+            continue
+
+        rule_list = lint_section.get(key, [])
+        if not isinstance(rule_list, list):
+            continue
+        for rule_code in rule_list:
+            rule_str = str(rule_code).strip().upper()
+            if rule_str in deprecated_codes:
+                found_deprecated = True
+                msg = (
+                    f"Upstream config uses deprecated rule '{rule_str}' "
+                    f"(found in [{'lint' if is_ruff_toml else 'tool.ruff.lint'}].{key}). "
+                    "This rule may be removed in a future Ruff version."
+                )
+                if strict:
+                    LOGGER.error(f"❌ {msg}")
+                else:
+                    LOGGER.warning(f"⚠️  {msg}")
+
+    return not (strict and found_deprecated)
+
+
 def validate_toml_syntax(doc: TOMLDocument) -> bool:
     """Return True if the document serializes to valid TOML.
 
@@ -218,6 +311,13 @@ def validate_merged_config(
         return False
     if not validate_ruff_accepts_config(doc, is_ruff_toml=is_ruff_toml, strict=strict):
         return False
+
+    version_ok = True
     if not is_ruff_toml:
-        return check_python_version_consistency(doc, strict=strict, exclude=exclude)
-    return True
+        version_ok = check_python_version_consistency(doc, strict=strict, exclude=exclude)
+
+    deprecated_ok = check_deprecated_rules(
+        doc, is_ruff_toml=is_ruff_toml, strict=strict, exclude=exclude
+    )
+
+    return version_ok and deprecated_ok

{ruff_sync-0.1.6.dev2.dist-info → ruff_sync-0.1.6.dev4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ruff-sync
-Version: 0.1.6.dev2
+Version: 0.1.6.dev4
 Summary: Synchronize Ruff linter configuration across projects
 Project-URL: Homepage, https://github.com/Kilo59/ruff-sync
 Project-URL: Documentation, https://kilo59.github.io/ruff-sync/

{ruff_sync-0.1.6.dev2.dist-info → ruff_sync-0.1.6.dev4.dist-info}/RECORD

@@ -1,15 +1,15 @@
 ruff_sync/__init__.py,sha256=M_1YK0BcPzlLlxlBOEPEBTCkAVm37r-yoQzGGZnfQ7Y,1206
 ruff_sync/__main__.py,sha256=oMIbv9ywToleBKJrZ-GMo_KhM4lHg02nJe7t6neWzJE,179
-ruff_sync/cli.py,sha256=HaDQgSB9TpPetuFBcc8_KAPjMVoJkaPxRVsX5uLkn6g,22193
+ruff_sync/cli.py,sha256=ieZVvMD2AlaHWSfXLidQhCRD87VmzcqV6J50tjnNRuc,25345
 ruff_sync/config_io.py,sha256=3GlFjFlii_hBLaNnUJRfFI0iozkngTBbfqu4rLrpZKQ,4348
-ruff_sync/constants.py,sha256=yE6ORJaErY8Bz5KTDDk7kRKLOlJ-xgS7Gvz_mFpjDJY,4604
-ruff_sync/core.py,sha256=R9IhMGlBAwrylNqZ7JpdffmjOj-A_ssZL9ViPFwcr5A,43819
+ruff_sync/constants.py,sha256=g7ZU8mGdQ2682tKQuKkhRaTRRmg0K2vMVp3Ljs60D70,5822
+ruff_sync/core.py,sha256=H2qJ_fn887ijlBh1Q4gh_24VHpzOqRjv5fvsNFhS0r0,44278
 ruff_sync/dependencies.py,sha256=RpJXAsrB-Y-ol_ZH4U92XIuyq8_bWaYwp9sn9KpxraA,2096
 ruff_sync/formatters.py,sha256=A4p2XAyc-xnteUmdtRXbp63fIjT9MdyKF6qKvcyNMho,29908
 ruff_sync/pre_commit.py,sha256=0ltXUkmocbrSwwf6cPbNc_K5K9n-gvou98xJy9YUhr0,5303
 ruff_sync/system.py,sha256=vF9Jjb-Z9MuLwo3wiOqcCDxniNtjvo3O-aFt4NJf-2Y,5715
 ruff_sync/types_.py,sha256=BejR6sgctR0qr5fKgRTtgHp2TqnvT8zTRo1NJi2VHLo,824
-ruff_sync/validation.py,sha256=6gSI17TSdgJsPx3VyCJPtOn6ME6fIWOj9UgU7xI-5nA,8223
+ruff_sync/validation.py,sha256=OatdkWUKEyxw7CYTOFNpH6IRsbVfU5EHjt6Lu6nOO9U,11585
 ruff_sync/tui/__init__.py,sha256=DcwvE70ETjBcC6pQeHpjrYtkJp8z4StGM8L3EuaVcIo,635
 ruff_sync/tui/app.py,sha256=soq0fkFsLeB7ZxJWNZM_H6bNj7H8p6nEYyirVcskN54,9317
 ruff_sync/tui/constants.py,sha256=fEPyp2k817QLluyiVHqDObzDONlHz_L3Ec0SYAUzzMs,267
@@ -17,8 +17,8 @@ ruff_sync/tui/screens.py,sha256=NVIlqNIr64JrFFWeec7usqJCb1x41NEmSfRZGeEcwuo,5557
 ruff_sync/tui/themes.py,sha256=-x9u_8iZPa1XZuo8O_tWVHyCImN9Qs9F7xPhl0VLwZw,654
 ruff_sync/tui/types_.py,sha256=poNUBJotgUso2IkUi3nXUuxz6wv1goFWZimj4VttdJE,8271
 ruff_sync/tui/widgets.py,sha256=2m3gyH4xDBpM0CK-5eQmmUCZXYKJujrbyVkFTxqmHcg,9760
-ruff_sync-0.1.6.dev2.dist-info/METADATA,sha256=gsszzmgDXK05MeDAx6lH1vNB1Lei-8em2NZSWSAwc04,22706
-ruff_sync-0.1.6.dev2.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-ruff_sync-0.1.6.dev2.dist-info/entry_points.txt,sha256=QQ0pjxMIN0vp5EmNFkyb-1Yk8JOIkid8zAPN3IpAExA,78
-ruff_sync-0.1.6.dev2.dist-info/licenses/LICENSE.md,sha256=RcCP8t8xyCx2cvMZSLjBrPqJfctciWC6q85ceQAcEfA,1080
-ruff_sync-0.1.6.dev2.dist-info/RECORD,,
+ruff_sync-0.1.6.dev4.dist-info/METADATA,sha256=8Z7T_-halUxzrgamLZkseVji5ARHpLJMdYxPo8pg6HM,22706
+ruff_sync-0.1.6.dev4.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+ruff_sync-0.1.6.dev4.dist-info/entry_points.txt,sha256=QQ0pjxMIN0vp5EmNFkyb-1Yk8JOIkid8zAPN3IpAExA,78
+ruff_sync-0.1.6.dev4.dist-info/licenses/LICENSE.md,sha256=RcCP8t8xyCx2cvMZSLjBrPqJfctciWC6q85ceQAcEfA,1080
+ruff_sync-0.1.6.dev4.dist-info/RECORD,,