auto-analyser 0.2.0__tar.gz

auto_analyser-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Michael Borck
+
+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.

auto_analyser-0.2.0/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: auto-analyser
+Version: 0.2.0
+Summary: Auto-analyser — detect a file's format and route it to the right analyser family member
+License-File: LICENSE
+Requires-Python: >=3.11
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: pyyaml>=6.0.0
+Requires-Dist: rich>=13.0.0
+Provides-Extra: dev
+Requires-Dist: pytest-cov>=4.0.0; extra == 'dev'
+Requires-Dist: pytest>=8.0.0; extra == 'dev'
+Requires-Dist: respx>=0.21.0; extra == 'dev'

auto_analyser-0.2.0/README.md

@@ -0,0 +1,83 @@
+# multi-analyser
+
+Routes any file to the right analyser. Detects the file format, calls the appropriate tool, and returns the result — so you don't need to know which analyser handles which format.
+
+Part of the [analyser family](#the-analyser-family).
+
+## Install
+
+```bash
+pip install multi-analyser
+```
+
+Requires Python 3.11+. The analysers it calls must be installed and reachable separately.
+
+## Usage
+
+### CLI
+
+```bash
+# Detect which analyser would handle a file
+multi-analyser detect report.pdf       # report.pdf -> document-analyser
+multi-analyser detect interview.mp3    # interview.mp3 -> speech-analyser
+multi-analyser detect data.xlsx        # data.xlsx -> records-analyser
+
+# Analyse a file — auto-detects format and routes
+multi-analyser analyse report.pdf
+multi-analyser analyse recording.mp3 --json
+
+# Force a specific analyser
+multi-analyser analyse interview.mp4 --analyser speech-analyser
+
+# Check which analysers are reachable
+multi-analyser status
+```
+
+### Python
+
+```python
+from poly_lens import Router
+
+router = Router()
+result = router.route("report.pdf")
+print(result["routed_to"])   # "document-analyser"
+```
+
+## Configuration
+
+multi-analyser ships with built-in defaults (document-analyser on `localhost:8000`, speech-analyser via CLI, etc.). Override with a YAML config file at `./multi-analyser.yaml` or `~/.config/multi-analyser/config.yaml`:
+
+```yaml
+lenses:
+  document-analyser:
+    type: http
+    url: http://localhost:8000
+    extensions: [.pdf, .docx, .pptx, .txt, .md]
+
+  speech-analyser:
+    type: cli
+    command: speech-analyser
+    extensions: [.mp3, .wav, .m4a, .ogg, .flac, .mp4, .mov]
+
+  records-analyser:
+    type: http
+    url: http://localhost:8003
+    extensions: [.csv, .tsv, .xlsx, .parquet, .db, .sqlite]
+```
+
+## The analyser family
+
+Low-level analysis tools. Each accepts files directly and returns structured JSON. Build your own UI or pipeline on top.
+
+| Package | Handles |
+|---|---|
+| [speech-analyser](https://github.com/michael-borck/speech-analyser) | audio and video files — transcript and speech metrics |
+| [video-analyser](https://github.com/michael-borck/video-analyser) | video files — frames, scenes, and visual quality |
+| [document-analyser](https://github.com/michael-borck/document-analyser) | PDF, DOCX, PPTX, TXT — text and readability |
+| [code-analyser](https://github.com/michael-borck/code-analyser) | source code — style, complexity, and quality metrics |
+| [records-analyser](https://github.com/michael-borck/records-analyser) | CSV, Excel, SQLite, Parquet, JSON — data profiling |
+| [multi-analyser](https://github.com/michael-borck/multi-analyser) | any file — detects format and routes to the right tool |
+
+## License
+
+MIT

auto_analyser-0.2.0/poly-lens.example.yaml

@@ -0,0 +1,36 @@
+# poly-lens configuration
+# Copy to ~/.config/poly-lens/config.yaml or ./poly-lens.yaml and adjust.
+#
+# Rate limiting: handled by reverse proxy (nginx, Caddy) for public deployments.
+# Each lens can be run as CLI (default, no server needed) or HTTP (start server first).
+
+lenses:
+  document-lens:
+    type: http
+    url: http://localhost:8000
+
+  # audio-lens: CLI by default (audiolens must be installed).
+  # Switch to http if running: audiolens serve --port 8001
+  audio-lens:
+    type: cli
+    command: audiolens
+  # audio-lens:
+  #   type: http
+  #   url: http://localhost:8001
+
+  # data-lens: CLI by default (datalens must be installed).
+  # Switch to http if running: datalens serve --port 8002
+  data-lens:
+    type: cli
+    command: datalens
+  # data-lens:
+  #   type: http
+  #   url: http://localhost:8002
+
+  code-lens:
+    type: http
+    url: http://localhost:8003
+
+  video-lens:
+    type: cli
+    command: videolens

auto_analyser-0.2.0/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "auto-analyser"
+version = "0.2.0"
+description = "Auto-analyser — detect a file's format and route it to the right analyser family member"
+requires-python = ">=3.11"
+dependencies = [
+    "httpx>=0.27.0",
+    "PyYAML>=6.0.0",
+    "rich>=13.0.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-cov>=4.0.0",
+    "respx>=0.21.0",
+]
+
+[project.scripts]
+auto-analyser = "auto_analyser.cli:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/auto_analyser"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]

auto_analyser-0.2.0/src/auto_analyser/__init__.py

@@ -0,0 +1,3 @@
+from .router import Router
+
+__all__ = ["Router"]

auto_analyser-0.2.0/src/auto_analyser/cli.py

@@ -0,0 +1,125 @@
+"""auto-analyser CLI — file analysis router.
+
+Usage:
+  auto-analyser report.pdf
+  auto-analyser data.csv --analyser records-analyser
+  auto-analyser recording.mp3 --json
+  auto-analyser detect notebook.ipynb
+  auto-analyser status
+"""
+
+import json
+import sys
+from pathlib import Path
+
+
+def main() -> None:
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        prog="auto-analyser",
+        description="Route files to the right analyser",
+    )
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    analyse = sub.add_parser("analyse", help="Analyse a file")
+    analyse.add_argument("file", type=Path, help="File to analyse")
+    analyse.add_argument("--analyser", help="Force a specific analyser (e.g. code-analyser)")
+    analyse.add_argument("--json", action="store_true", dest="as_json", help="Output raw JSON")
+
+    detect_cmd = sub.add_parser("detect", help="Show which analyser would handle a file")
+    detect_cmd.add_argument("file", type=Path)
+
+    sub.add_parser("status", help="Show configured analysers and whether they are reachable")
+
+    args = parser.parse_args()
+
+    if args.command == "analyse":
+        _cmd_analyse(args)
+    elif args.command == "detect":
+        _cmd_detect(args)
+    elif args.command == "status":
+        _cmd_status()
+
+
+def _cmd_analyse(args) -> None:
+    from .router import Router, RoutingError
+
+    router = Router()
+
+    try:
+        result = router.route(args.file, analyser_name=args.analyser)
+    except RoutingError as e:
+        if args.as_json:
+            print(json.dumps({"error": str(e)}, indent=2, default=str), file=sys.stderr)
+        else:
+            print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    if args.as_json:
+        print(json.dumps(result, indent=2, default=str))
+        return
+
+    if result.get("warning"):
+        print(f"Note: {result['warning']}\n")
+
+    print(f"Routed to:  {result.get('routed_to', 'unknown')}")
+    print()
+    print("Full result (use --json for machine-readable output):")
+    _print_summary({k: v for k, v in result.items() if k not in ("routed_to", "warning")})
+
+
+def _cmd_detect(args) -> None:
+    from .detector import detect
+
+    result = detect(args.file)
+    if result.warning:
+        print(f"Note: {result.warning}")
+    if result.analyser:
+        print(f"{args.file.name} -> {result.analyser}")
+    else:
+        print(f"{args.file.name} -> unknown (no analyser configured for {result.extension})")
+        sys.exit(1)
+
+
+def _cmd_status() -> None:
+    from .config import load_config
+    import httpx
+
+    config = load_config()
+    print("Configured analysers:\n")
+
+    for name, cfg in config.analysers.items():
+        if cfg.type == "http":
+            try:
+                httpx.get(f"{cfg.url}/health", timeout=3).raise_for_status()
+                status = "reachable"
+            except Exception:
+                status = "not reachable"
+            print(f"  {name:<22} http  {cfg.url}  {status}")
+        else:
+            import subprocess
+            try:
+                subprocess.run([cfg.command, "--version"], capture_output=True, timeout=5)
+                status = "installed"
+            except FileNotFoundError:
+                status = "not found"
+            except subprocess.TimeoutExpired:
+                status = "installed (timeout on --version)"
+            print(f"  {name:<22} cli   {cfg.command}  {status}")
+
+
+def _print_summary(data: dict) -> None:
+    for key, value in data.items():
+        if isinstance(value, dict):
+            print(f"  {key}:")
+            for k, v in value.items():
+                print(f"    {k}: {v}")
+        elif isinstance(value, list):
+            print(f"  {key}: [{len(value)} items]")
+        else:
+            print(f"  {key}: {value}")
+
+
+if __name__ == "__main__":
+    main()

auto_analyser-0.2.0/src/auto_analyser/config.py

@@ -0,0 +1,67 @@
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Literal
+
+import yaml
+
+
+@dataclass
+class AnalyserConfig:
+    type: Literal["http", "cli"]
+    url: str | None = None       # for type=http
+    command: str | None = None   # for type=cli
+    formats: list[str] = field(default_factory=list)
+
+
+@dataclass
+class FamilyConfig:
+    analysers: dict[str, AnalyserConfig]
+
+    def get(self, analyser_name: str) -> AnalyserConfig | None:
+        return self.analysers.get(analyser_name)
+
+    def available(self) -> list[str]:
+        return list(self.analysers.keys())
+
+
+_DEFAULTS: dict[str, dict] = {
+    "document-analyser":  {"type": "http", "url": "http://localhost:8000"},
+    "speech-analyser":    {"type": "http", "url": "http://localhost:8001"},
+    "video-analyser":     {"type": "http", "url": "http://localhost:8002"},
+    "records-analyser":   {"type": "http", "url": "http://localhost:8003"},
+    "code-analyser":      {"type": "http", "url": "http://localhost:8004"},
+    "wordpress-analyser": {"type": "http", "url": "http://localhost:8005"},
+}
+
+_CONFIG_PATHS = [
+    Path("auto-analyser.yaml"),
+    Path.home() / ".config" / "auto-analyser" / "config.yaml",
+]
+
+
+def load_config() -> FamilyConfig:
+    """Load family config. Falls back to built-in defaults if no file found."""
+    raw: dict = {}
+
+    for path in _CONFIG_PATHS:
+        if path.exists():
+            with open(path) as f:
+                raw = yaml.safe_load(f) or {}
+            break
+
+    merged = {**_DEFAULTS, **raw.get("analysers", {})}
+    analysers = {}
+    for name, cfg in merged.items():
+        if "type" not in cfg:
+            raise ValueError(
+                f"Analyser '{name}' in config is missing required field 'type'. "
+                f"Must be 'http' or 'cli'."
+            )
+        analysers[name] = AnalyserConfig(
+            type=cfg["type"],
+            url=cfg.get("url"),
+            command=cfg.get("command"),
+            formats=cfg.get("formats", []),
+        )
+
+    return FamilyConfig(analysers=analysers)

auto_analyser-0.2.0/src/auto_analyser/detector.py

@@ -0,0 +1,95 @@
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass
+class DetectionResult:
+    analyser: str | None    # None if unknown
+    extension: str
+    warning: str | None = None
+
+
+# Extension → analyser name
+_ROUTES: dict[str, str] = {
+    # document-analyser
+    ".pdf": "document-analyser",
+    ".docx": "document-analyser",
+    ".pptx": "document-analyser",
+    ".txt": "document-analyser",
+    ".md": "document-analyser",
+    ".qmd": "document-analyser",
+    ".rst": "document-analyser",
+    # speech-analyser
+    ".mp3": "speech-analyser",
+    ".wav": "speech-analyser",
+    ".m4a": "speech-analyser",
+    ".ogg": "speech-analyser",
+    ".flac": "speech-analyser",
+    ".aac": "speech-analyser",
+    ".opus": "speech-analyser",
+    # records-analyser
+    ".csv": "records-analyser",
+    ".tsv": "records-analyser",
+    ".xlsx": "records-analyser",
+    ".xls": "records-analyser",
+    ".parquet": "records-analyser",
+    ".sqlite": "records-analyser",
+    ".db": "records-analyser",
+    ".sqlite3": "records-analyser",
+    # records-analyser (ambiguous)
+    ".json": "records-analyser",
+    ".yaml": "records-analyser",
+    ".yml": "records-analyser",
+    ".xml": "records-analyser",
+    # code-analyser
+    ".py": "code-analyser",
+    ".js": "code-analyser",
+    ".ts": "code-analyser",
+    ".tsx": "code-analyser",
+    ".jsx": "code-analyser",
+    ".html": "code-analyser",
+    ".css": "code-analyser",
+    ".scss": "code-analyser",
+    ".sql": "code-analyser",
+    ".ipynb": "code-analyser",
+    # video-analyser
+    ".mp4": "video-analyser",
+    ".mov": "video-analyser",
+    ".avi": "video-analyser",
+    ".webm": "video-analyser",
+    ".mkv": "video-analyser",
+    # wordpress-analyser
+    ".php": "wordpress-analyser",
+}
+
+_AMBIGUOUS_WARNING = (
+    "{ext} files may be configuration data or structured datasets. "
+    "auto-analyser is routing to records-analyser. "
+    "For prose content, use document-analyser directly."
+)
+
+_NOTEBOOK_WARNING = (
+    "{ext} is a notebook format containing both code and prose. "
+    "code-analyser will analyse the code cells. "
+    "Pass extracted prose to document-analyser for writing quality analysis."
+)
+
+
+def detect(file_path: Path) -> DetectionResult:
+    """Detect which analyser should handle this file."""
+    ext = file_path.suffix.lower()
+    analyser = _ROUTES.get(ext)
+
+    warning = None
+    if ext in {".json", ".yaml", ".yml", ".xml"}:
+        warning = _AMBIGUOUS_WARNING.format(ext=ext.upper())
+    elif ext in {".ipynb", ".qmd", ".rmd"}:
+        warning = _NOTEBOOK_WARNING.format(ext=ext)
+    elif analyser is None:
+        warning = (
+            f"Unknown format: {ext}. "
+            f"auto-analyser does not know which analyser handles this file. "
+            f"Use an analyser directly or add a mapping to your auto-analyser.yaml."
+        )
+
+    return DetectionResult(analyser=analyser, extension=ext, warning=warning)

auto_analyser-0.2.0/src/auto_analyser/router.py

@@ -0,0 +1,132 @@
+import json
+import subprocess
+from pathlib import Path
+from typing import Any
+
+import httpx
+
+from .config import FamilyConfig, load_config
+from .detector import detect
+
+
+class RoutingError(Exception):
+    """Raised when auto-analyser cannot route or analyse a file."""
+
+
+class Router:
+    """Routes a file to the appropriate analyser and returns the analysis."""
+
+    def __init__(self, config: FamilyConfig | None = None) -> None:
+        self._config = config or load_config()
+
+    def route(
+        self,
+        file_path: "Path | str",
+        analyser_name: str | None = None,
+    ) -> dict[str, Any]:
+        """Analyse a file by routing to the appropriate analyser.
+
+        Returns the analysis dict with a 'routed_to' key injected.
+
+        Raises:
+            RoutingError: if the file is missing, format unknown, analyser not
+                          configured, or the analyser returns an error.
+        """
+        if isinstance(file_path, str):
+            file_path = Path(file_path)
+
+        if not file_path.exists():
+            raise RoutingError(f"File not found: {file_path}")
+        if not file_path.is_file():
+            raise RoutingError(f"Not a file: {file_path}")
+
+        warning = None
+
+        if analyser_name is None:
+            detection = detect(file_path)
+            if detection.analyser is None:
+                raise RoutingError(
+                    f"Unknown format: {file_path.suffix}. "
+                    f"Use --analyser to specify an analyser directly."
+                )
+            analyser_name = detection.analyser
+            warning = detection.warning
+
+        analyser_cfg = self._config.get(analyser_name)
+        if analyser_cfg is None:
+            raise RoutingError(
+                f"Analyser '{analyser_name}' is not configured. "
+                f"Available: {self._config.available()}"
+            )
+
+        if analyser_cfg.type == "cli":
+            if not analyser_cfg.command:
+                raise RoutingError(
+                    f"Analyser '{analyser_name}' has type=cli but no command configured."
+                )
+            data = self._call_cli(analyser_cfg.command, file_path)
+        elif analyser_cfg.type == "http":
+            if not analyser_cfg.url:
+                raise RoutingError(
+                    f"Analyser '{analyser_name}' has type=http but no url configured."
+                )
+            data = self._call_http(analyser_cfg.url, file_path)
+        else:
+            raise RoutingError(f"Unknown analyser type: {analyser_cfg.type}")
+
+        data["routed_to"] = analyser_name
+        if warning:
+            data["warning"] = warning
+        return data
+
+    def _call_cli(self, command: str, file_path: Path) -> dict[str, Any]:
+        try:
+            proc = subprocess.run(
+                [command, str(file_path), "--json"],
+                capture_output=True,
+                text=True,
+                timeout=300,
+            )
+            if proc.returncode != 0:
+                try:
+                    err = json.loads(proc.stderr)
+                    msg = err.get("error", proc.stderr.strip())
+                except (json.JSONDecodeError, AttributeError):
+                    msg = proc.stderr.strip() or f"{command} exited with code {proc.returncode}"
+                raise RoutingError(msg)
+            try:
+                return json.loads(proc.stdout)
+            except json.JSONDecodeError as e:
+                raise RoutingError(
+                    f"{command} returned invalid JSON: {e}. "
+                    f"stdout={proc.stdout[:200]!r}"
+                )
+        except FileNotFoundError:
+            raise RoutingError(f"CLI tool '{command}' not found. Is it installed?")
+        except RoutingError:
+            raise
+        except Exception as e:
+            raise RoutingError(str(e)) from e
+
+    def _call_http(self, url: str, file_path: Path) -> dict[str, Any]:
+        """POST file to {url}/analyse."""
+        try:
+            with open(file_path, "rb") as f:
+                with httpx.Client(timeout=300) as client:
+                    response = client.post(
+                        f"{url}/analyse",
+                        files={"file": (file_path.name, f)},
+                    )
+            if not response.is_success:
+                try:
+                    detail = response.json().get("detail", response.text)
+                except Exception:
+                    detail = response.text
+                raise RoutingError(f"HTTP {response.status_code}: {detail}")
+            return response.json()
+        except httpx.ConnectError:
+            raise RoutingError(f"Cannot connect to {url}. Is the service running?")
+        except RoutingError:
+            raise
+        except Exception as e:
+            raise RoutingError(str(e)) from e

auto_analyser-0.2.0/src/multi_analyser/__init__.py

@@ -0,0 +1,3 @@
+from .router import Router
+
+__all__ = ["Router"]