assert-no-linter-config-files 20260103181222__py3-none-any.whl

assert_no_linter_config_files/__main__.py

@@ -0,0 +1,5 @@
+"""Entry point for python -m assert_no_linter_config_files."""
+
+from .cli import main
+
+main()

assert_no_linter_config_files/cli.py

@@ -0,0 +1,209 @@
+"""Command-line interface for assert-no-linter-config-files."""
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from .scanner import (
+    VALID_LINTERS,
+    Finding,
+    get_config_files_for_linters,
+    parse_linters,
+    scan_directory,
+)
+
+EXIT_SUCCESS = 0
+EXIT_FINDINGS = 1
+EXIT_ERROR = 2
+
+
+def create_parser() -> argparse.ArgumentParser:
+    """Create and configure the argument parser."""
+    linters_list = ", ".join(sorted(VALID_LINTERS))
+
+    parser = argparse.ArgumentParser(
+        prog="assert-no-linter-config-files",
+        description="Assert that no linter config files exist in directories.",
+    )
+    parser.add_argument(
+        "directories",
+        nargs="+",
+        type=Path,
+        metavar="DIRECTORY",
+        help="One or more directories to scan.",
+    )
+    parser.add_argument(
+        "--linters",
+        required=True,
+        metavar="LINTERS",
+        help=f"Comma-separated linters to check. Options: {linters_list}",
+    )
+    parser.add_argument(
+        "--exclude",
+        action="append",
+        default=None,
+        metavar="PATTERN",
+        help="Glob pattern to exclude paths (repeatable).",
+    )
+
+    # Output mode group (mutually exclusive)
+    output_group = parser.add_mutually_exclusive_group()
+    output_group.add_argument(
+        "--quiet",
+        action="store_true",
+        help="Suppress output, exit code only.",
+    )
+    output_group.add_argument(
+        "--count",
+        action="store_true",
+        help="Print finding count only.",
+    )
+    output_group.add_argument(
+        "--json",
+        action="store_true",
+        help="Output findings as JSON.",
+    )
+    output_group.add_argument(
+        "-v",
+        "--verbose",
+        action="store_true",
+        help="Show linters, directories scanned, findings, and summary.",
+    )
+
+    # Behavior modifiers (mutually exclusive)
+    behavior_group = parser.add_mutually_exclusive_group()
+    behavior_group.add_argument(
+        "--fail-fast",
+        action="store_true",
+        help="Exit on first finding.",
+    )
+    behavior_group.add_argument(
+        "--warn-only",
+        action="store_true",
+        help="Always exit 0, report only.",
+    )
+
+    return parser
+
+
+def output_findings(
+    findings: list[Finding],
+    use_json: bool,
+    use_count: bool,
+) -> None:
+    """Output findings in the appropriate format."""
+    if use_json:
+        print(json.dumps([f.to_dict() for f in findings]))
+    elif use_count:
+        print(len(findings))
+    else:
+        for finding in findings:
+            print(finding)
+
+
+def _print_verbose_summary(dirs_scanned: int, finding_count: int) -> None:
+    """Print verbose summary of scan results."""
+    print(f"Scanned {dirs_scanned} directory(ies), found {finding_count} finding(s)")
+
+
+def _handle_fail_fast(
+    finding: Finding,
+    dirs_scanned: int,
+    args: argparse.Namespace,
+) -> None:
+    """Handle fail-fast output and exit."""
+    if args.verbose:
+        print(finding)
+        _print_verbose_summary(dirs_scanned, 1)
+    elif not args.quiet:
+        output_findings([finding], args.json, args.count)
+    sys.exit(EXIT_FINDINGS)
+
+
+def _determine_exit_code(
+    all_findings: list[Finding],
+    had_error: bool,
+    warn_only: bool,
+) -> int:
+    """Determine the exit code based on results."""
+    if warn_only:
+        return EXIT_SUCCESS
+    if all_findings:
+        return EXIT_FINDINGS
+    if had_error:
+        return EXIT_ERROR
+    return EXIT_SUCCESS
+
+
+def _process_directory(
+    directory: Path,
+    args: argparse.Namespace,
+    linters: frozenset[str],
+    dirs_scanned: int,
+    all_findings: list[Finding],
+) -> tuple[int, bool]:
+    """Process a single directory. Returns (dirs_scanned, had_error)."""
+    if args.verbose:
+        print(f"Scanning: {directory}")
+
+    try:
+        findings = scan_directory(
+            directory,
+            linters=linters,
+            exclude_patterns=args.exclude,
+        )
+        dirs_scanned += 1
+
+        if findings and args.fail_fast:
+            _handle_fail_fast(findings[0], dirs_scanned, args)
+
+        if args.verbose:
+            for finding in findings:
+                print(finding)
+
+        all_findings.extend(findings)
+        return dirs_scanned, False
+    except OSError as e:
+        print(f"Error reading: {e}", file=sys.stderr)
+        return dirs_scanned, True
+
+
+def main() -> None:
+    """Run the assert-no-linter-config-files CLI."""
+    parser = create_parser()
+    args = parser.parse_args()
+
+    try:
+        linters = parse_linters(args.linters)
+    except ValueError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(EXIT_ERROR)
+
+    if args.verbose:
+        print(f"Checking for: {', '.join(sorted(linters))}")
+        config_files = get_config_files_for_linters(linters)
+        for linter, configs in config_files.items():
+            print(f"  {linter}: {', '.join(configs)}")
+
+    all_findings: list[Finding] = []
+    had_error = False
+    dirs_scanned = 0
+
+    for directory in args.directories:
+        if not directory.is_dir():
+            print(f"Error: '{directory}' is not a directory", file=sys.stderr)
+            had_error = True
+            continue
+
+        dirs_scanned, dir_error = _process_directory(
+            directory, args, linters, dirs_scanned, all_findings
+        )
+        had_error = had_error or dir_error
+
+    if args.verbose:
+        _print_verbose_summary(dirs_scanned, len(all_findings))
+    elif not args.quiet:
+        output_findings(all_findings, args.json, args.count)
+
+    sys.exit(_determine_exit_code(all_findings, had_error, args.warn_only))

assert_no_linter_config_files/scanner.py

@@ -0,0 +1,320 @@
+"""Scanner for detecting linter configuration files and sections."""
+
+import configparser
+import fnmatch
+import os
+import re
+from dataclasses import dataclass
+from pathlib import Path
+
+try:
+    import tomllib
+    HAS_TOMLLIB = True
+except ImportError:  # pragma: no cover (Python < 3.11)
+    HAS_TOMLLIB = False
+
+VALID_LINTERS: frozenset[str] = frozenset({
+    "pylint", "pytest", "mypy", "yamllint", "jscpd"
+})
+
+DEDICATED_CONFIG_FILES: dict[str, str] = {
+    ".pylintrc": "pylint",
+    "pylintrc": "pylint",
+    ".pylintrc.toml": "pylint",
+    "pytest.ini": "pytest",
+    "mypy.ini": "mypy",
+    ".mypy.ini": "mypy",
+    ".yamllint": "yamllint",
+    ".yamllint.yml": "yamllint",
+    ".yamllint.yaml": "yamllint",
+    ".jscpd.json": "jscpd",
+    ".jscpd.yml": "jscpd",
+    ".jscpd.yaml": "jscpd",
+    ".jscpd.toml": "jscpd",
+    ".jscpdrc": "jscpd",
+    ".jscpdrc.json": "jscpd",
+    ".jscpdrc.yml": "jscpd",
+    ".jscpdrc.yaml": "jscpd",
+}
+
+SHARED_CONFIG_SECTIONS: dict[str, dict[str, str]] = {
+    "pylint": {
+        "pyproject.toml": "[tool.pylint.*]",
+        "setup.cfg": "[pylint.*]",
+        "tox.ini": "[pylint.*]",
+    },
+    "pytest": {
+        "pyproject.toml": "[tool.pytest.ini_options]",
+        "setup.cfg": "[tool:pytest]",
+        "tox.ini": "[pytest] or [tool:pytest]",
+    },
+    "mypy": {
+        "pyproject.toml": "[tool.mypy]",
+        "setup.cfg": "[mypy]",
+        "tox.ini": "[mypy]",
+    },
+    "yamllint": {
+        "pyproject.toml": "[tool.yamllint.*]",
+    },
+    "jscpd": {
+        "pyproject.toml": "[tool.jscpd.*]",
+    },
+}
+
+
+def get_config_files_for_linters(linters: frozenset[str]) -> dict[str, list[str]]:
+    """Get the config files that will be checked for each linter.
+
+    Args:
+        linters: Set of linter names to get config files for.
+
+    Returns:
+        Dictionary mapping each linter to its list of config file descriptions.
+    """
+    result: dict[str, list[str]] = {}
+
+    for linter in sorted(linters):
+        configs: list[str] = []
+
+        # Add dedicated config files
+        dedicated = sorted(
+            filename for filename, tool in DEDICATED_CONFIG_FILES.items()
+            if tool == linter
+        )
+        configs.extend(dedicated)
+
+        # Add shared config sections
+        if linter in SHARED_CONFIG_SECTIONS:
+            for shared_file, section in SHARED_CONFIG_SECTIONS[linter].items():
+                configs.append(f"{section} in {shared_file}")
+
+        result[linter] = configs
+
+    return result
+
+
+def make_path_relative(path: str) -> str:
+    """Convert an absolute path to a relative path from cwd."""
+    try:
+        return str(Path(path).relative_to(Path.cwd()))
+    except ValueError:
+        return path
+
+
+@dataclass(frozen=True)
+class Finding:
+    """Represents a detected linter configuration."""
+
+    path: str
+    tool: str
+    reason: str
+
+    def __str__(self) -> str:
+        """Format the finding as path:tool:reason."""
+        relative_path = make_path_relative(self.path)
+        return f"{relative_path}:{self.tool}:{self.reason}"
+
+    def to_dict(self) -> dict[str, str]:
+        """Convert finding to dictionary for JSON output."""
+        return {
+            "path": self.path,
+            "tool": self.tool,
+            "reason": self.reason,
+        }
+
+
+def parse_linters(linters_str: str) -> frozenset[str]:
+    """Parse comma-separated linters string and validate.
+
+    Args:
+        linters_str: Comma-separated list of linter names.
+
+    Returns:
+        Frozenset of valid linter names.
+
+    Raises:
+        ValueError: If any linter name is invalid.
+    """
+    linters = frozenset(
+        t.strip().lower() for t in linters_str.split(",") if t.strip()
+    )
+
+    invalid = linters - VALID_LINTERS
+    if invalid:
+        valid_list = ", ".join(sorted(VALID_LINTERS))
+        invalid_list = ", ".join(sorted(invalid))
+        raise ValueError(
+            f"Invalid linter(s): {invalid_list}. Valid options: {valid_list}"
+        )
+
+    if not linters:
+        raise ValueError("At least one linter must be specified")
+
+    return linters
+
+
+def _check_pyproject_with_tomllib(
+    path_str: str, tool_section: dict[str, object]
+) -> list[Finding]:
+    """Check tool section using parsed TOML data."""
+    findings: list[Finding] = []
+    if "pylint" in tool_section:
+        findings.append(Finding(path_str, "pylint", "tool.pylint section"))
+    if "mypy" in tool_section:
+        findings.append(Finding(path_str, "mypy", "tool.mypy section"))
+    if "pytest" in tool_section:
+        pytest_section = tool_section["pytest"]
+        if isinstance(pytest_section, dict) and "ini_options" in pytest_section:
+            findings.append(
+                Finding(path_str, "pytest", "tool.pytest.ini_options section")
+            )
+    if "jscpd" in tool_section:
+        findings.append(Finding(path_str, "jscpd", "tool.jscpd section"))
+    if "yamllint" in tool_section:
+        findings.append(Finding(path_str, "yamllint", "tool.yamllint section"))
+    return findings
+
+
+def _check_pyproject_with_regex(path_str: str, content: str) -> list[Finding]:
+    """Check pyproject.toml content using regex fallback."""
+    findings: list[Finding] = []
+    if re.search(r"^\[tool\.pylint", content, re.MULTILINE):
+        findings.append(Finding(path_str, "pylint", "tool.pylint section"))
+    if re.search(r"^\[tool\.mypy\]", content, re.MULTILINE):
+        findings.append(Finding(path_str, "mypy", "tool.mypy section"))
+    if re.search(r"^\[tool\.pytest\.ini_options\]", content, re.MULTILINE):
+        findings.append(
+            Finding(path_str, "pytest", "tool.pytest.ini_options section")
+        )
+    if re.search(r"^\[tool\.jscpd", content, re.MULTILINE):
+        findings.append(Finding(path_str, "jscpd", "tool.jscpd section"))
+    if re.search(r"^\[tool\.yamllint", content, re.MULTILINE):
+        findings.append(Finding(path_str, "yamllint", "tool.yamllint section"))
+    return findings
+
+
+def check_pyproject_toml(path: Path, content: str) -> list[Finding]:
+    """Check pyproject.toml for tool-specific sections."""
+    path_str = str(path)
+
+    if HAS_TOMLLIB:
+        try:
+            data = tomllib.loads(content)
+            tool_section = data.get("tool", {})
+            return _check_pyproject_with_tomllib(path_str, tool_section)
+        except (tomllib.TOMLDecodeError, ValueError, KeyError, TypeError):
+            pass
+
+    return _check_pyproject_with_regex(path_str, content)
+
+
+def check_setup_cfg(path: Path, content: str) -> list[Finding]:
+    """Check setup.cfg for tool-specific sections."""
+    findings: list[Finding] = []
+    path_str = str(path)
+
+    parser = configparser.ConfigParser()
+    try:
+        parser.read_string(content)
+    except configparser.Error:
+        return findings
+
+    for section in parser.sections():
+        if section == "mypy":
+            findings.append(Finding(path_str, "mypy", "mypy section"))
+        elif section == "tool:pytest":
+            findings.append(Finding(path_str, "pytest", "tool:pytest section"))
+        elif "pylint" in section.lower():
+            findings.append(Finding(path_str, "pylint", f"{section} section"))
+
+    return findings
+
+
+def check_tox_ini(path: Path, content: str) -> list[Finding]:
+    """Check tox.ini for tool-specific sections."""
+    findings: list[Finding] = []
+    path_str = str(path)
+
+    parser = configparser.ConfigParser()
+    try:
+        parser.read_string(content)
+    except configparser.Error:
+        return findings
+
+    for section in parser.sections():
+        if section in ("pytest", "tool:pytest"):
+            findings.append(Finding(path_str, "pytest", f"{section} section"))
+        elif section == "mypy":
+            findings.append(Finding(path_str, "mypy", "mypy section"))
+        elif "pylint" in section.lower():
+            findings.append(Finding(path_str, "pylint", f"{section} section"))
+
+    return findings
+
+
+def _process_shared_config_file(
+    file_path: Path, filename: str
+) -> list[Finding]:
+    """Process shared config files (pyproject.toml, setup.cfg, tox.ini)."""
+    content = file_path.read_text(encoding="utf-8")
+    if filename == "pyproject.toml":
+        return check_pyproject_toml(file_path, content)
+    if filename == "setup.cfg":
+        return check_setup_cfg(file_path, content)
+    # filename == "tox.ini"
+    return check_tox_ini(file_path, content)
+
+
+def _matches_exclude_pattern(
+    path: str, exclude_patterns: list[str]
+) -> bool:
+    """Check if path matches any exclude pattern."""
+    for pattern in exclude_patterns:
+        if fnmatch.fnmatch(path, pattern):
+            return True
+    return False
+
+
+def scan_directory(
+    directory: Path,
+    linters: frozenset[str],
+    exclude_patterns: list[str] | None = None,
+) -> list[Finding]:
+    """Scan a directory recursively for linter configuration files.
+
+    Args:
+        directory: The directory to scan.
+        linters: Set of linters to check.
+        exclude_patterns: List of glob patterns to exclude paths.
+
+    Returns:
+        A list of Finding objects for each config found.
+    """
+    if exclude_patterns is None:
+        exclude_patterns = []
+
+    findings: list[Finding] = []
+    shared_config_files = {"pyproject.toml", "setup.cfg", "tox.ini"}
+
+    for root, dirs, files in os.walk(directory):
+        if ".git" in dirs:
+            dirs.remove(".git")
+
+        for filename in files:
+            file_path = Path(root) / filename
+            path_str = str(file_path)
+
+            # Check exclude patterns
+            if _matches_exclude_pattern(path_str, exclude_patterns):
+                continue
+
+            if filename in DEDICATED_CONFIG_FILES:
+                tool = DEDICATED_CONFIG_FILES[filename]
+                if tool in linters:
+                    findings.append(Finding(path_str, tool, "config file"))
+            elif filename in shared_config_files:
+                file_findings = _process_shared_config_file(file_path, filename)
+                # Filter by requested linters
+                findings.extend(f for f in file_findings if f.tool in linters)
+
+    return findings

assert_no_linter_config_files-20260103181222.dist-info/METADATA

@@ -0,0 +1,180 @@
+Metadata-Version: 2.4
+Name: assert-no-linter-config-files
+Version: 20260103181222
+Summary: CLI tool to assert that no linter config files exist
+Author-email: 10U Labs <dev@10ulabs.com>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/10U-Labs-LLC/assert-no-linter-config-files
+Project-URL: Issues, https://github.com/10U-Labs-LLC/assert-no-linter-config-files/issues
+Project-URL: Repository, https://github.com/10U-Labs-LLC/assert-no-linter-config-files
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Dynamic: license-file
+
+# assert-no-linter-config-files
+
+A command-line tool that asserts there are no configuration files (or embedded
+configuration sections) for common linters in your codebase. This is useful for
+enforcing that linter configurations are managed centrally rather than in
+individual repositories.
+
+## Installation
+
+```bash
+pip install assert-no-linter-config-files
+```
+
+Or install from source:
+
+```bash
+pip install -e .
+```
+
+## Usage
+
+```bash
+assert-no-linter-config-files --linters LINTERS [OPTIONS] DIRECTORY [DIRECTORY ...]
+```
+
+### Required Arguments
+
+- `--linters LINTERS` - Comma-separated linters to check: `pylint,mypy,pytest,yamllint,jscpd`
+- `DIRECTORY` - One or more directories to scan
+
+### Optional Arguments
+
+- `--exclude PATTERN` - Glob pattern to exclude paths (repeatable)
+- `--quiet` - Suppress output, exit code only
+- `--count` - Print finding count only
+- `--json` - Output findings as JSON
+- `--fail-fast` - Exit on first finding
+- `--warn-only` - Always exit 0, report only
+
+### Exit Codes
+
+- `0` - No linter configuration found (or `--warn-only`)
+- `1` - One or more linter configurations found
+- `2` - Usage/runtime error (invalid args, unreadable files)
+
+### Examples
+
+Check for pylint and mypy configs in the current directory:
+
+```bash
+assert-no-linter-config-files --linters pylint,mypy .
+```
+
+Check specific directories:
+
+```bash
+assert-no-linter-config-files --linters pylint,mypy src/ tests/
+```
+
+Check all linters:
+
+```bash
+assert-no-linter-config-files --linters pylint,mypy,pytest,yamllint,jscpd .
+```
+
+Exclude vendor directories:
+
+```bash
+assert-no-linter-config-files --linters pylint,mypy \
+  --exclude "*vendor*" --exclude "*node_modules*" .
+```
+
+Get JSON output for CI integration:
+
+```bash
+assert-no-linter-config-files --linters pylint --json . | jq .
+```
+
+Use in CI to enforce no local linter configs:
+
+```bash
+assert-no-linter-config-files --linters pylint,mypy . || exit 1
+```
+
+## What It Checks
+
+### Dedicated Config Files
+
+The tool flags the presence of these files anywhere in the scanned tree:
+
+**pylint:** `.pylintrc`, `pylintrc`, `.pylintrc.toml`
+
+**pytest:** `pytest.ini`
+
+**mypy:** `mypy.ini`, `.mypy.ini`
+
+**yamllint:** `.yamllint`, `.yamllint.yml`, `.yamllint.yaml`
+
+**jscpd:** `.jscpd.json`, `.jscpd.yml`, `.jscpd.yaml`, `.jscpd.toml`,
+`.jscpdrc`, `.jscpdrc.json`, `.jscpdrc.yml`, `.jscpdrc.yaml`
+
+### Embedded Config Sections
+
+The tool also checks shared config files for tool-specific sections:
+
+**pyproject.toml:**
+
+- `[tool.pylint]` or `[tool.pylint.*]`
+- `[tool.mypy]`
+- `[tool.pytest.ini_options]`
+- `[tool.jscpd]`
+- `[tool.yamllint]`
+
+**setup.cfg:**
+
+- `[mypy]`
+- `[tool:pytest]`
+- Any section containing "pylint"
+
+**tox.ini:**
+
+- `[pytest]` or `[tool:pytest]`
+- `[mypy]`
+- Any section containing "pylint"
+
+## Output Format
+
+When findings are detected, each is printed on a separate line:
+
+```text
+<path>:<tool>:<reason>
+```
+
+Examples:
+
+```text
+./pytest.ini:pytest:config file
+./pyproject.toml:mypy:tool.mypy section
+./setup.cfg:pylint:pylint.messages_control section
+```
+
+With `--json`:
+
+```json
+[{"path": "./pytest.ini", "tool": "pytest", "reason": "config file"}]
+```
+
+## CI Checks
+
+The following checks run on every push and pull request:
+
+- **yamllint** - YAML linting for workflow files
+- **markdownlint** - Markdown linting
+- **pylint** - Python linting for source and test code
+- **mypy** - Static type checking for source code
+- **jscpd** - Duplicate code detection
+- **pytest** - Unit, integration, and E2E tests

assert_no_linter_config_files-20260103181222.dist-info/RECORD

@@ -0,0 +1,11 @@
+assert_no_linter_config_files/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+assert_no_linter_config_files/__main__.py,sha256=U8gT1p3t8bAvDLQg1fmWUG9ihjuLGiKGwiselStVBik,94
+assert_no_linter_config_files/cli.py,sha256=XUJOYlvB8_ShGqZ3sMg_unkSaNa6-rdlSNQDvzoCs9w,5607
+assert_no_linter_config_files/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+assert_no_linter_config_files/scanner.py,sha256=RPXba8HlM6m5L3j_1NB30VASgKEy7zduEbsRuk-_4UQ,10062
+assert_no_linter_config_files-20260103181222.dist-info/licenses/LICENSE.txt,sha256=dl6gJivslVJcwUu-EWVFNCR64UpMpEXiz4olTSt17Sg,10761
+assert_no_linter_config_files-20260103181222.dist-info/METADATA,sha256=nA1VBYfZIQlj93t08eCDw11jvI5FRsopegxJ6ME9Eko,4508
+assert_no_linter_config_files-20260103181222.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+assert_no_linter_config_files-20260103181222.dist-info/entry_points.txt,sha256=qQrnULgXqcS_n_5453-LciShwVjtUMUDTnPOGM-TPlo,89
+assert_no_linter_config_files-20260103181222.dist-info/top_level.txt,sha256=c8bMFXQQuhU_Bwj8vQGdzkJMWad69k8z5WVkByghxcw,30
+assert_no_linter_config_files-20260103181222.dist-info/RECORD,,

assert_no_linter_config_files-20260103181222.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

assert_no_linter_config_files-20260103181222.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+assert-no-linter-config-files = assert_no_linter_config_files.cli:main

assert_no_linter_config_files-20260103181222.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,190 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to the Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright 2025 10U Labs LLC
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

assert_no_linter_config_files-20260103181222.dist-info/top_level.txt

@@ -0,0 +1 @@
+assert_no_linter_config_files