detect-file-type-local 0.1.0__tar.gz

detect_file_type_local-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 detect-file-type-skill contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

detect_file_type_local-0.1.0/NOTICE

@@ -0,0 +1,12 @@
+detect-file-type-skill
+Copyright (c) 2026 detect-file-type-skill contributors
+
+This product includes software developed by Google LLC:
+
+  Magika - AI-powered file type detection
+  Copyright 2024 Google LLC
+  Licensed under the Apache License, Version 2.0
+  https://github.com/google/magika
+
+You may obtain a copy of the Apache License, Version 2.0 at:
+  http://www.apache.org/licenses/LICENSE-2.0

detect_file_type_local-0.1.0/PKG-INFO

@@ -0,0 +1,110 @@
+Metadata-Version: 2.4
+Name: detect-file-type-local
+Version: 0.1.0
+Summary: Security-focused local file type detection powered by Google Magika
+License-Expression: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE
+Requires-Dist: magika<2.0.0,>=1.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: ruff>=0.4; extra == "dev"
+Dynamic: license-file
+
+# detect-file-type-local
+
+[![CI](https://github.com/pgeraghty/openclaw-detect-file-type-local/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/pgeraghty/openclaw-detect-file-type-local/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/github/license/pgeraghty/openclaw-detect-file-type-local)](LICENSE)
+![Python 3.8+](https://img.shields.io/badge/python-3.8%2B-blue)
+![Inference: Local/Offline](https://img.shields.io/badge/inference-local%20%7C%20offline-success)
+![API Keys](https://img.shields.io/badge/api_keys-none-success)
+
+An [OpenClaw](https://openclaw.org) skill for AI-powered local file type detection.
+
+Wraps [Google Magika](https://github.com/google/magika) to provide ML-based file type identification that runs entirely offline. No API keys, no network calls — just local inference on an embedded ONNX model.
+
+## Features
+
+- **214 file types** detected by content, not extension
+- **Fully offline** — no network access required
+- **Fast** — only reads the bytes needed for classification
+- **Batch support** — process multiple files or entire directories
+- **Multiple output formats** — JSON, human-readable, bare MIME type
+- **Stdin support** — pipe content directly
+
+## Quick Start
+
+```bash
+pip install -e .
+
+# Detect a single file
+detect-file-type-local document.pdf
+
+# Batch detect
+detect-file-type-local --human *.pdf *.png
+
+# Recursive directory scan
+detect-file-type-local -r ./uploads/
+
+# Pipe from stdin
+cat mystery_file | detect-file-type-local -
+```
+
+Compatibility alias: `detect-file-type` remains available.
+
+## Output Formats
+
+**JSON (default):**
+```json
+{
+  "path": "photo.jpg",
+  "label": "jpeg",
+  "mime_type": "image/jpeg",
+  "score": 0.99,
+  "group": "image",
+  "description": "JPEG image",
+  "is_text": false
+}
+```
+
+**Human-readable:**
+```
+photo.jpg: JPEG image (image/jpeg) [score: 0.99]
+```
+
+**MIME-only:**
+```
+image/jpeg
+```
+
+## OpenClaw Skill
+
+See [SKILL.md](SKILL.md) for the OpenClaw skill definition, including structured output schemas and usage guidance for LLM integration.
+
+Note: this skill currently uses manual local installation (`pip install -e ...`). Auto-install metadata will be added after a public package artifact is published and resolvable.
+
+## Development
+
+```bash
+pip install -e '.[dev]'
+pytest tests/ -v
+ruff check .
+```
+
+## Release
+
+PyPI publishing is automated via GitHub Actions (`Publish Python Package` workflow):
+
+1. Create a GitHub release with a tag matching package version (for example, `v0.1.0`)
+2. Workflow builds and validates artifacts
+3. Workflow publishes to PyPI via trusted publishing
+
+After PyPI release, update and republish the ClawHub skill metadata to enable auto-install from `detect-file-type-local`.
+
+## License
+
+MIT — see [LICENSE](LICENSE).
+
+This project uses [Google Magika](https://github.com/google/magika) (Apache-2.0). See [NOTICE](NOTICE) and [THIRD_PARTY_LICENSES.md](THIRD_PARTY_LICENSES.md).

detect_file_type_local-0.1.0/README.md

@@ -0,0 +1,95 @@
+# detect-file-type-local
+
+[![CI](https://github.com/pgeraghty/openclaw-detect-file-type-local/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/pgeraghty/openclaw-detect-file-type-local/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/github/license/pgeraghty/openclaw-detect-file-type-local)](LICENSE)
+![Python 3.8+](https://img.shields.io/badge/python-3.8%2B-blue)
+![Inference: Local/Offline](https://img.shields.io/badge/inference-local%20%7C%20offline-success)
+![API Keys](https://img.shields.io/badge/api_keys-none-success)
+
+An [OpenClaw](https://openclaw.org) skill for AI-powered local file type detection.
+
+Wraps [Google Magika](https://github.com/google/magika) to provide ML-based file type identification that runs entirely offline. No API keys, no network calls — just local inference on an embedded ONNX model.
+
+## Features
+
+- **214 file types** detected by content, not extension
+- **Fully offline** — no network access required
+- **Fast** — only reads the bytes needed for classification
+- **Batch support** — process multiple files or entire directories
+- **Multiple output formats** — JSON, human-readable, bare MIME type
+- **Stdin support** — pipe content directly
+
+## Quick Start
+
+```bash
+pip install -e .
+
+# Detect a single file
+detect-file-type-local document.pdf
+
+# Batch detect
+detect-file-type-local --human *.pdf *.png
+
+# Recursive directory scan
+detect-file-type-local -r ./uploads/
+
+# Pipe from stdin
+cat mystery_file | detect-file-type-local -
+```
+
+Compatibility alias: `detect-file-type` remains available.
+
+## Output Formats
+
+**JSON (default):**
+```json
+{
+  "path": "photo.jpg",
+  "label": "jpeg",
+  "mime_type": "image/jpeg",
+  "score": 0.99,
+  "group": "image",
+  "description": "JPEG image",
+  "is_text": false
+}
+```
+
+**Human-readable:**
+```
+photo.jpg: JPEG image (image/jpeg) [score: 0.99]
+```
+
+**MIME-only:**
+```
+image/jpeg
+```
+
+## OpenClaw Skill
+
+See [SKILL.md](SKILL.md) for the OpenClaw skill definition, including structured output schemas and usage guidance for LLM integration.
+
+Note: this skill currently uses manual local installation (`pip install -e ...`). Auto-install metadata will be added after a public package artifact is published and resolvable.
+
+## Development
+
+```bash
+pip install -e '.[dev]'
+pytest tests/ -v
+ruff check .
+```
+
+## Release
+
+PyPI publishing is automated via GitHub Actions (`Publish Python Package` workflow):
+
+1. Create a GitHub release with a tag matching package version (for example, `v0.1.0`)
+2. Workflow builds and validates artifacts
+3. Workflow publishes to PyPI via trusted publishing
+
+After PyPI release, update and republish the ClawHub skill metadata to enable auto-install from `detect-file-type-local`.
+
+## License
+
+MIT — see [LICENSE](LICENSE).
+
+This project uses [Google Magika](https://github.com/google/magika) (Apache-2.0). See [NOTICE](NOTICE) and [THIRD_PARTY_LICENSES.md](THIRD_PARTY_LICENSES.md).

detect_file_type_local-0.1.0/detect_file_type/__init__.py

@@ -0,0 +1,3 @@
+"""detect-file-type: AI-powered local file type detection via Google Magika."""
+
+__version__ = "0.1.0"

detect_file_type_local-0.1.0/detect_file_type/__main__.py

@@ -0,0 +1,5 @@
+"""Allow running as `python -m detect_file_type`."""
+
+from detect_file_type.cli import main
+
+main()

detect_file_type_local-0.1.0/detect_file_type/cli.py

@@ -0,0 +1,147 @@
+"""CLI entry point for detect-file-type."""
+
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+from pathlib import Path
+from typing import List
+
+from magika import Magika
+
+from detect_file_type.formatter import (
+    format_human,
+    format_json,
+    format_mime,
+    result_to_dict,
+)
+
+STDIN_MAX_BYTES = 1_048_576  # 1 MB
+
+
+def collect_paths(args_paths: List[str], recursive: bool) -> List[str]:
+    """Expand directories if --recursive, otherwise return paths as-is."""
+    expanded = []
+    for p in args_paths:
+        if p == "-":
+            expanded.append("-")
+            continue
+        path = Path(p)
+        if recursive and path.is_dir():
+            for root, _dirs, files in os.walk(path):
+                for f in sorted(files):
+                    expanded.append(os.path.join(root, f))
+        else:
+            expanded.append(p)
+    return expanded
+
+
+def detect_files(magika_instance: Magika, paths: List[str]) -> tuple:
+    """Detect file types. Returns (results_list, had_errors)."""
+    results = []
+    had_errors = False
+
+    # Separate stdin from file paths while preserving original indices
+    file_entries = [(i, p) for i, p in enumerate(paths) if p != "-"]
+    stdin_indices = [i for i, p in enumerate(paths) if p == "-"]
+
+    # Handle stdin (single stream only)
+    if len(stdin_indices) > 1:
+        print("error: multiple stdin inputs are not supported; use '-' only once", file=sys.stderr)
+        had_errors = True
+    elif len(stdin_indices) == 1:
+        idx = stdin_indices[0]
+        try:
+            data = sys.stdin.buffer.read(STDIN_MAX_BYTES)
+            result = magika_instance.identify_bytes(data)
+            results.append((idx, result_to_dict("-", result)))
+        except Exception as e:
+            print(f"error: stdin: {e}", file=sys.stderr)
+            had_errors = True
+
+    # Handle file paths
+    if file_entries:
+        valid_file_entries = []
+        path_objects = []
+        for idx, p in file_entries:
+            pp = Path(p)
+            if not pp.exists():
+                print(f"error: {p}: No such file or directory", file=sys.stderr)
+                had_errors = True
+                continue
+            if not pp.is_file():
+                print(f"error: {p}: Not a regular file", file=sys.stderr)
+                had_errors = True
+                continue
+            try:
+                # Check readability
+                with open(pp, "rb"):
+                    pass
+            except PermissionError:
+                print(f"error: {p}: Permission denied", file=sys.stderr)
+                had_errors = True
+                continue
+            valid_file_entries.append((idx, p))
+            path_objects.append(pp)
+
+        if path_objects:
+            try:
+                magika_results = magika_instance.identify_paths(path_objects)
+                for (idx, p_str), result in zip(valid_file_entries, magika_results):
+                    results.append((idx, result_to_dict(p_str, result)))
+            except Exception as e:
+                print(f"error: detection failed: {e}", file=sys.stderr)
+                had_errors = True
+
+    # Sort by original order
+    results.sort(key=lambda x: x[0])
+    return [r[1] for r in results], had_errors
+
+
+def main(argv: List[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(
+        prog="detect-file-type",
+        description="AI-powered local file type detection using Google Magika",
+    )
+    parser.add_argument("paths", nargs="+", help="File paths to detect (use - for stdin)")
+    parser.add_argument(
+        "--json", dest="format", action="store_const", const="json", help="JSON output (default)"
+    )
+    parser.add_argument(
+        "--human", dest="format", action="store_const", const="human", help="Human-readable output"
+    )
+    parser.add_argument(
+        "--mime", dest="format", action="store_const", const="mime", help="Bare MIME type output"
+    )
+    parser.add_argument(
+        "--recursive", "-r", action="store_true", help="Recurse into directories"
+    )
+    parser.set_defaults(format="json")
+
+    args = parser.parse_args(argv)
+
+    paths = collect_paths(args.paths, args.recursive)
+    if not paths:
+        print("error: no files to process", file=sys.stderr)
+        sys.exit(1)
+
+    magika_instance = Magika()
+    results, had_errors = detect_files(magika_instance, paths)
+
+    if not results:
+        sys.exit(1)
+
+    if args.format == "json":
+        print(format_json(results))
+    elif args.format == "human":
+        print(format_human(results))
+    elif args.format == "mime":
+        print(format_mime(results))
+
+    if had_errors:
+        sys.exit(2)
+
+
+if __name__ == "__main__":
+    main()

detect_file_type_local-0.1.0/detect_file_type/formatter.py

@@ -0,0 +1,42 @@
+"""Output formatting for file type detection results."""
+
+from __future__ import annotations
+
+import json
+from typing import Any, Dict, List
+
+
+def result_to_dict(path: str, result: Any) -> Dict[str, Any]:
+    """Convert a magika result to a plain dict."""
+    output = result.output
+    return {
+        "path": path,
+        "label": output.label,
+        "mime_type": output.mime_type,
+        "score": round(result.score, 4),
+        "group": output.group,
+        "description": output.description,
+        "is_text": output.is_text,
+    }
+
+
+def format_json(results: List[Dict[str, Any]]) -> str:
+    """Format results as JSON. Single result returns an object; multiple returns an array."""
+    if len(results) == 1:
+        return json.dumps(results[0], indent=2)
+    return json.dumps(results, indent=2)
+
+
+def format_human(results: List[Dict[str, Any]]) -> str:
+    """Format results as human-readable lines."""
+    lines = []
+    for r in results:
+        lines.append(
+            f"{r['path']}: {r['description']} ({r['mime_type']}) [score: {r['score']:.2f}]"
+        )
+    return "\n".join(lines)
+
+
+def format_mime(results: List[Dict[str, Any]]) -> str:
+    """Format results as bare MIME types, one per line."""
+    return "\n".join(r["mime_type"] for r in results)

detect_file_type_local-0.1.0/detect_file_type_local.egg-info/PKG-INFO

@@ -0,0 +1,110 @@
+Metadata-Version: 2.4
+Name: detect-file-type-local
+Version: 0.1.0
+Summary: Security-focused local file type detection powered by Google Magika
+License-Expression: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE
+Requires-Dist: magika<2.0.0,>=1.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: ruff>=0.4; extra == "dev"
+Dynamic: license-file
+
+# detect-file-type-local
+
+[![CI](https://github.com/pgeraghty/openclaw-detect-file-type-local/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/pgeraghty/openclaw-detect-file-type-local/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/github/license/pgeraghty/openclaw-detect-file-type-local)](LICENSE)
+![Python 3.8+](https://img.shields.io/badge/python-3.8%2B-blue)
+![Inference: Local/Offline](https://img.shields.io/badge/inference-local%20%7C%20offline-success)
+![API Keys](https://img.shields.io/badge/api_keys-none-success)
+
+An [OpenClaw](https://openclaw.org) skill for AI-powered local file type detection.
+
+Wraps [Google Magika](https://github.com/google/magika) to provide ML-based file type identification that runs entirely offline. No API keys, no network calls — just local inference on an embedded ONNX model.
+
+## Features
+
+- **214 file types** detected by content, not extension
+- **Fully offline** — no network access required
+- **Fast** — only reads the bytes needed for classification
+- **Batch support** — process multiple files or entire directories
+- **Multiple output formats** — JSON, human-readable, bare MIME type
+- **Stdin support** — pipe content directly
+
+## Quick Start
+
+```bash
+pip install -e .
+
+# Detect a single file
+detect-file-type-local document.pdf
+
+# Batch detect
+detect-file-type-local --human *.pdf *.png
+
+# Recursive directory scan
+detect-file-type-local -r ./uploads/
+
+# Pipe from stdin
+cat mystery_file | detect-file-type-local -
+```
+
+Compatibility alias: `detect-file-type` remains available.
+
+## Output Formats
+
+**JSON (default):**
+```json
+{
+  "path": "photo.jpg",
+  "label": "jpeg",
+  "mime_type": "image/jpeg",
+  "score": 0.99,
+  "group": "image",
+  "description": "JPEG image",
+  "is_text": false
+}
+```
+
+**Human-readable:**
+```
+photo.jpg: JPEG image (image/jpeg) [score: 0.99]
+```
+
+**MIME-only:**
+```
+image/jpeg
+```
+
+## OpenClaw Skill
+
+See [SKILL.md](SKILL.md) for the OpenClaw skill definition, including structured output schemas and usage guidance for LLM integration.
+
+Note: this skill currently uses manual local installation (`pip install -e ...`). Auto-install metadata will be added after a public package artifact is published and resolvable.
+
+## Development
+
+```bash
+pip install -e '.[dev]'
+pytest tests/ -v
+ruff check .
+```
+
+## Release
+
+PyPI publishing is automated via GitHub Actions (`Publish Python Package` workflow):
+
+1. Create a GitHub release with a tag matching package version (for example, `v0.1.0`)
+2. Workflow builds and validates artifacts
+3. Workflow publishes to PyPI via trusted publishing
+
+After PyPI release, update and republish the ClawHub skill metadata to enable auto-install from `detect-file-type-local`.
+
+## License
+
+MIT — see [LICENSE](LICENSE).
+
+This project uses [Google Magika](https://github.com/google/magika) (Apache-2.0). See [NOTICE](NOTICE) and [THIRD_PARTY_LICENSES.md](THIRD_PARTY_LICENSES.md).

detect_file_type_local-0.1.0/detect_file_type_local.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+LICENSE
+NOTICE
+README.md
+pyproject.toml
+detect_file_type/__init__.py
+detect_file_type/__main__.py
+detect_file_type/cli.py
+detect_file_type/formatter.py
+detect_file_type_local.egg-info/PKG-INFO
+detect_file_type_local.egg-info/SOURCES.txt
+detect_file_type_local.egg-info/dependency_links.txt
+detect_file_type_local.egg-info/entry_points.txt
+detect_file_type_local.egg-info/requires.txt
+detect_file_type_local.egg-info/top_level.txt
+tests/test_cli.py
+tests/test_detection.py

detect_file_type_local-0.1.0/detect_file_type_local.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

detect_file_type_local-0.1.0/detect_file_type_local.egg-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+detect-file-type = detect_file_type.cli:main
+detect-file-type-local = detect_file_type.cli:main

detect_file_type_local-0.1.0/detect_file_type_local.egg-info/requires.txt

@@ -0,0 +1,5 @@
+magika<2.0.0,>=1.0.0
+
+[dev]
+pytest>=7.0
+ruff>=0.4

detect_file_type_local-0.1.0/detect_file_type_local.egg-info/top_level.txt

@@ -0,0 +1 @@
+detect_file_type

detect_file_type_local-0.1.0/pyproject.toml

@@ -0,0 +1,34 @@
+[build-system]
+requires = ["setuptools>=68.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "detect-file-type-local"
+version = "0.1.0"
+description = "Security-focused local file type detection powered by Google Magika"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.8"
+dependencies = [
+    "magika>=1.0.0,<2.0.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "ruff>=0.4",
+]
+
+[project.scripts]
+detect-file-type-local = "detect_file_type.cli:main"
+detect-file-type = "detect_file_type.cli:main"
+
+[tool.ruff]
+target-version = "py38"
+line-length = 100
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "I"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

detect_file_type_local-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

detect_file_type_local-0.1.0/tests/test_cli.py

@@ -0,0 +1,160 @@
+"""CLI integration tests."""
+
+from __future__ import annotations
+
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+FIXTURES_DIR = Path(__file__).parent / "fixtures"
+CLI_MODULE = [sys.executable, "-m", "detect_file_type"]
+
+
+def run_cli(*args: str, stdin_data: bytes | None = None) -> subprocess.CompletedProcess:
+    return subprocess.run(
+        [*CLI_MODULE, *args],
+        capture_output=True,
+        text=stdin_data is None,
+        input=stdin_data if stdin_data is not None else None,
+        timeout=60,
+    )
+
+
+def run_cli_text(*args: str) -> subprocess.CompletedProcess:
+    return subprocess.run(
+        [*CLI_MODULE, *args],
+        capture_output=True,
+        text=True,
+        timeout=60,
+    )
+
+
+class TestJsonOutput:
+    def test_single_file_json(self):
+        result = run_cli_text(str(FIXTURES_DIR / "sample.png"))
+        assert result.returncode == 0
+        data = json.loads(result.stdout)
+        assert data["label"] == "png"
+        assert data["mime_type"] == "image/png"
+        assert isinstance(data["score"], float)
+        assert data["group"] == "image"
+        assert isinstance(data["is_text"], bool)
+
+    def test_multiple_files_json(self):
+        result = run_cli_text(
+            str(FIXTURES_DIR / "tiny.txt"),
+            str(FIXTURES_DIR / "sample.png"),
+        )
+        assert result.returncode == 0
+        data = json.loads(result.stdout)
+        assert isinstance(data, list)
+        assert len(data) == 2
+
+    def test_json_output_parseable(self):
+        result = run_cli_text(str(FIXTURES_DIR / "sample.zip"))
+        data = json.loads(result.stdout)
+        required_keys = {"path", "label", "mime_type", "score", "group", "description", "is_text"}
+        assert required_keys.issubset(data.keys())
+
+    def test_duplicate_paths_preserve_order(self):
+        tiny = str(FIXTURES_DIR / "tiny.txt")
+        png = str(FIXTURES_DIR / "sample.png")
+        result = run_cli_text(tiny, png, tiny)
+        assert result.returncode == 0
+        data = json.loads(result.stdout)
+        assert [item["path"] for item in data] == [tiny, png, tiny]
+
+
+class TestHumanOutput:
+    def test_human_format(self):
+        result = run_cli_text("--human", str(FIXTURES_DIR / "sample.png"))
+        assert result.returncode == 0
+        assert "image/png" in result.stdout
+        assert "score:" in result.stdout
+
+    def test_human_batch(self):
+        result = run_cli_text(
+            "--human",
+            str(FIXTURES_DIR / "tiny.txt"),
+            str(FIXTURES_DIR / "sample.png"),
+        )
+        assert result.returncode == 0
+        lines = result.stdout.strip().split("\n")
+        assert len(lines) == 2
+
+
+class TestMimeOutput:
+    def test_mime_format(self):
+        result = run_cli_text("--mime", str(FIXTURES_DIR / "sample.png"))
+        assert result.returncode == 0
+        assert result.stdout.strip() == "image/png"
+
+    def test_mime_batch(self):
+        result = run_cli_text(
+            "--mime",
+            str(FIXTURES_DIR / "tiny.txt"),
+            str(FIXTURES_DIR / "sample.png"),
+        )
+        lines = result.stdout.strip().split("\n")
+        assert len(lines) == 2
+
+
+class TestErrorHandling:
+    def test_nonexistent_file(self):
+        result = run_cli_text(str(FIXTURES_DIR / "does_not_exist.xyz"))
+        assert result.returncode != 0
+        assert "No such file" in result.stderr
+
+    def test_empty_file(self):
+        result = run_cli_text(str(FIXTURES_DIR / "empty.bin"))
+        assert result.returncode == 0
+        data = json.loads(result.stdout)
+        assert data["label"] == "empty"
+
+    def test_partial_failure_exit_code(self):
+        result = run_cli_text(
+            str(FIXTURES_DIR / "sample.png"),
+            str(FIXTURES_DIR / "does_not_exist.xyz"),
+        )
+        # Should exit 2 (partial failure) — some files succeeded, some failed
+        assert result.returncode == 2
+
+    def test_partial_failure_preserves_success_order_with_duplicates(self):
+        tiny = str(FIXTURES_DIR / "tiny.txt")
+        png = str(FIXTURES_DIR / "sample.png")
+        missing = str(FIXTURES_DIR / "does_not_exist.xyz")
+
+        result = run_cli_text(tiny, missing, png, tiny)
+        assert result.returncode == 2
+        data = json.loads(result.stdout)
+        assert [item["path"] for item in data] == [tiny, png, tiny]
+
+
+class TestStdin:
+    def test_stdin_detection(self):
+        result = subprocess.run(
+            [*CLI_MODULE, "-"],
+            input=b"Hello, this is plain text content for stdin detection.\n" * 20,
+            capture_output=True,
+            timeout=60,
+        )
+        assert result.returncode == 0
+        data = json.loads(result.stdout)
+        assert data["path"] == "-"
+        assert data["group"] == "text"
+
+    def test_multiple_stdin_inputs_are_rejected(self):
+        result = run_cli("-", "-", stdin_data=b"hello from stdin\n" * 20)
+        assert result.returncode == 1
+        stderr = result.stderr.decode("utf-8", errors="replace")
+        assert "multiple stdin inputs are not supported" in stderr
+
+
+class TestRecursive:
+    def test_recursive_directory(self):
+        result = run_cli_text("--recursive", "--json", str(FIXTURES_DIR))
+        assert result.returncode == 0
+        data = json.loads(result.stdout)
+        assert isinstance(data, list)
+        assert len(data) >= 4  # At least our fixture files

detect_file_type_local-0.1.0/tests/test_detection.py

@@ -0,0 +1,60 @@
+"""Detection accuracy tests with real fixtures."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+from magika import Magika
+
+FIXTURES_DIR = Path(__file__).parent / "fixtures"
+
+
+@pytest.fixture(scope="module")
+def magika_instance():
+    return Magika()
+
+
+def test_detect_text(magika_instance):
+    result = magika_instance.identify_path(FIXTURES_DIR / "tiny.txt")
+    assert result.output.group == "text"
+
+
+def test_detect_png(magika_instance):
+    result = magika_instance.identify_path(FIXTURES_DIR / "sample.png")
+    assert result.output.label == "png"
+    assert result.output.mime_type == "image/png"
+
+
+def test_detect_zip(magika_instance):
+    result = magika_instance.identify_path(FIXTURES_DIR / "sample.zip")
+    assert result.output.label == "zip"
+
+
+def test_detect_empty(magika_instance):
+    result = magika_instance.identify_path(FIXTURES_DIR / "empty.bin")
+    assert result.output.label == "empty"
+
+
+def test_detect_misleading_extension(magika_instance):
+    """A file with .png extension but text content should detect as text, not PNG."""
+    result = magika_instance.identify_path(FIXTURES_DIR / "misleading.txt.png")
+    assert result.output.group == "text"
+    assert result.output.label != "png"
+
+
+def test_identify_bytes(magika_instance):
+    data = b"Hello, world! This is a plain text test string.\n" * 20
+    result = magika_instance.identify_bytes(data)
+    assert result.output.group == "text"
+
+
+def test_batch_detection(magika_instance):
+    paths = [
+        FIXTURES_DIR / "tiny.txt",
+        FIXTURES_DIR / "sample.png",
+        FIXTURES_DIR / "sample.zip",
+    ]
+    results = magika_instance.identify_paths(paths)
+    assert len(results) == 3
+    assert results[1].output.label == "png"