autoneat 0.2.2__tar.gz

autoneat-0.2.2/LICENSE

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

autoneat-0.2.2/PKG-INFO

@@ -0,0 +1,102 @@
+Metadata-Version: 2.4
+Name: autoneat
+Version: 0.2.2
+Summary: Standalone Neat Video Auto Profile automation for DaVinci Resolve
+Author: Mohammad Hadi
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/mhadifilms/autoneat
+Project-URL: Repository, https://github.com/mhadifilms/autoneat
+Project-URL: Issues, https://github.com/mhadifilms/autoneat/issues
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: dvr>=1.1
+Requires-Dist: pyobjc-framework-Quartz>=11.0; platform_system == "Darwin"
+Provides-Extra: test
+Requires-Dist: pytest>=8; extra == "test"
+Dynamic: license-file
+
+# autoneat
+
+Standalone Neat Video Pro 6 Auto Profile automation for DaVinci Resolve.
+
+Neat Video has no public scripting API for Auto Profile. `autoneat` scripts the
+parts Resolve exposes, then uses macOS window automation plus Apple Vision OCR
+for the two controls Neat does not expose: **Auto Profile** and **Apply**.
+
+## Install
+
+```bash
+python3 -m pip install autoneat
+```
+
+DaVinci Resolve Studio, Neat Video Pro 6, and macOS Accessibility / Screen
+Recording permissions are required. Run:
+
+```bash
+autoneat doctor
+```
+
+## CLI
+
+Run against the current Resolve project/timeline:
+
+```bash
+autoneat profile --state artifacts/neat/state.json
+```
+
+Run against a specific project/timeline and shot filter:
+
+```bash
+autoneat profile \
+  --project "My Show" \
+  --timeline "My Show_Neat" \
+  --shot-ids 001,002,003 \
+  --state artifacts/neat/state.json
+```
+
+Important options:
+
+- `--continue` resumes from the state JSON.
+- `--retry-failed` retries previously failed clips when resuming.
+- `--all-tracks` processes all video tracks instead of `--track 1`.
+- `--no-color-wrap` skips the ACES/HDR ColorSpaceTransform wrapper.
+- `--json` prints the final summary object after the live log.
+
+## Python API
+
+```python
+from autoneat import ProfileOptions, run_profile
+
+result = run_profile(
+    ProfileOptions(
+        project_name="My Show",
+        timeline_name="My Show_Neat",
+        shot_ids=["001", "002"],
+    )
+)
+```
+
+## How It Works
+
+For each selected timeline clip, `autoneat`:
+
+1. Moves the Resolve playhead to the clip.
+2. Adds or reuses the Neat Video OFX node.
+3. Wraps ACES/HDR clips with ColorSpaceTransform nodes so Neat sees
+   display-referred pixels.
+4. Opens Neat via the OFX `Prepare Profile___` button control.
+5. OCR-clicks Auto Profile, waits for readiness, then OCR-clicks Apply.
+6. Writes a state JSON after every clip for resumable batches.
+
+## Development
+
+```bash
+python3 -m venv .venv
+./.venv/bin/python -m pip install -e ".[test]"
+./.venv/bin/python -m pytest
+```
+
+## License
+
+[MIT](LICENSE).

autoneat-0.2.2/README.md

@@ -0,0 +1,84 @@
+# autoneat
+
+Standalone Neat Video Pro 6 Auto Profile automation for DaVinci Resolve.
+
+Neat Video has no public scripting API for Auto Profile. `autoneat` scripts the
+parts Resolve exposes, then uses macOS window automation plus Apple Vision OCR
+for the two controls Neat does not expose: **Auto Profile** and **Apply**.
+
+## Install
+
+```bash
+python3 -m pip install autoneat
+```
+
+DaVinci Resolve Studio, Neat Video Pro 6, and macOS Accessibility / Screen
+Recording permissions are required. Run:
+
+```bash
+autoneat doctor
+```
+
+## CLI
+
+Run against the current Resolve project/timeline:
+
+```bash
+autoneat profile --state artifacts/neat/state.json
+```
+
+Run against a specific project/timeline and shot filter:
+
+```bash
+autoneat profile \
+  --project "My Show" \
+  --timeline "My Show_Neat" \
+  --shot-ids 001,002,003 \
+  --state artifacts/neat/state.json
+```
+
+Important options:
+
+- `--continue` resumes from the state JSON.
+- `--retry-failed` retries previously failed clips when resuming.
+- `--all-tracks` processes all video tracks instead of `--track 1`.
+- `--no-color-wrap` skips the ACES/HDR ColorSpaceTransform wrapper.
+- `--json` prints the final summary object after the live log.
+
+## Python API
+
+```python
+from autoneat import ProfileOptions, run_profile
+
+result = run_profile(
+    ProfileOptions(
+        project_name="My Show",
+        timeline_name="My Show_Neat",
+        shot_ids=["001", "002"],
+    )
+)
+```
+
+## How It Works
+
+For each selected timeline clip, `autoneat`:
+
+1. Moves the Resolve playhead to the clip.
+2. Adds or reuses the Neat Video OFX node.
+3. Wraps ACES/HDR clips with ColorSpaceTransform nodes so Neat sees
+   display-referred pixels.
+4. Opens Neat via the OFX `Prepare Profile___` button control.
+5. OCR-clicks Auto Profile, waits for readiness, then OCR-clicks Apply.
+6. Writes a state JSON after every clip for resumable batches.
+
+## Development
+
+```bash
+python3 -m venv .venv
+./.venv/bin/python -m pip install -e ".[test]"
+./.venv/bin/python -m pytest
+```
+
+## License
+
+[MIT](LICENSE).

autoneat-0.2.2/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = ["setuptools>=69", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "autoneat"
+version = "0.2.2"
+description = "Standalone Neat Video Auto Profile automation for DaVinci Resolve"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+authors = [{ name = "Mohammad Hadi" }]
+dependencies = [
+  "dvr>=1.1",
+  "pyobjc-framework-Quartz>=11.0; platform_system == 'Darwin'",
+]
+
+[project.urls]
+Homepage = "https://github.com/mhadifilms/autoneat"
+Repository = "https://github.com/mhadifilms/autoneat"
+Issues = "https://github.com/mhadifilms/autoneat/issues"
+
+[project.optional-dependencies]
+test = [
+  "pytest>=8",
+]
+
+[project.scripts]
+autoneat = "autoneat.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+autoneat = ["resources/*"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]

autoneat-0.2.2/setup.cfg

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

autoneat-0.2.2/src/autoneat/__init__.py

@@ -0,0 +1,5 @@
+"""Standalone Neat Video Auto Profile automation."""
+
+from autoneat.api import ProfileOptions, run_profile
+
+__all__ = ["ProfileOptions", "run_profile"]

autoneat-0.2.2/src/autoneat/__main__.py

@@ -0,0 +1,3 @@
+from autoneat.cli import main
+
+raise SystemExit(main())

autoneat-0.2.2/src/autoneat/api.py

@@ -0,0 +1,56 @@
+"""Public Python API for standalone autoneat runs."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Callable, Optional
+
+from autoneat.core.batch import BatchSettings, run_batch
+from autoneat.resolve import connect_resolve
+
+
+@dataclass
+class ProfileOptions(BatchSettings):
+    """Options for a standalone Neat Video Auto Profile batch."""
+
+    project_name: Optional[str] = None
+    timeline_name: Optional[str] = None
+
+
+def run_profile(
+    options: ProfileOptions,
+    *,
+    resolve: Any = None,
+    project: Any = None,
+    timeline: Any = None,
+    sink: Optional[Callable[[str], None]] = None,
+    cancel_event: Any = None,
+) -> dict:
+    """Run Auto Profile against a Resolve project/timeline.
+
+    Tests and embedding callers may pass explicit Resolve handles. Normal CLI
+    usage lets autoneat connect through ``dvr`` and select the requested
+    project/timeline.
+    """
+    if resolve is not None and project is not None and timeline is not None:
+        return run_batch(
+            resolve,
+            project,
+            timeline,
+            options,
+            sink=sink,
+            cancel_event=cancel_event,
+        )
+
+    with connect_resolve(
+        project_name=options.project_name,
+        timeline_name=options.timeline_name,
+    ) as session:
+        return run_batch(
+            session.resolve,
+            session.project,
+            session.timeline,
+            options,
+            sink=sink,
+            cancel_event=cancel_event,
+        )

autoneat-0.2.2/src/autoneat/cli.py

@@ -0,0 +1,101 @@
+"""Command-line interface for autoneat."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from autoneat.api import ProfileOptions, run_profile
+from autoneat.doctor import check_environment, print_report
+
+
+def _parse_shot_ids(value: str | None) -> list[str]:
+    if not value:
+        return []
+    return [part.strip() for part in value.replace(",", " ").split() if part.strip()]
+
+
+def _profile(args: argparse.Namespace) -> int:
+    options = ProfileOptions(
+        project_name=args.project,
+        timeline_name=args.timeline,
+        track=args.track,
+        all_video_tracks=args.all_tracks,
+        shot_ids=_parse_shot_ids(args.shot_ids),
+        start_from=args.start_from,
+        limit=args.limit,
+        continue_run=args.continue_run,
+        retry_failed=args.retry_failed,
+        reuse_existing_neat=not args.no_reuse_existing,
+        no_color_wrap=args.no_color_wrap,
+        open_timeout=args.open_timeout,
+        editor_timeout=args.editor_timeout,
+        prepare_timeout=args.prepare_timeout,
+        profile_wait=args.profile_wait,
+        ready_timeout=args.ready_timeout,
+        apply_delay=args.apply_delay,
+        close_timeout=args.close_timeout,
+        step_delay=args.step_delay,
+        sidecar_path=Path(args.state).expanduser() if args.state else None,
+    )
+    result = run_profile(options, sink=lambda line: print(line, flush=True))
+    if args.json:
+        print(json.dumps(result, indent=2, sort_keys=True), flush=True)
+    return 0 if result.get("ok") else 1
+
+
+def _doctor(_args: argparse.Namespace) -> int:
+    return print_report(check_environment())
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="autoneat")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    doctor = sub.add_parser("doctor", help="Check macOS/Resolve automation prerequisites")
+    doctor.set_defaults(func=_doctor)
+
+    profile = sub.add_parser("profile", help="Run Neat Video Auto Profile over timeline clips")
+    profile.add_argument("--project", help="Resolve project name (default: current project)")
+    profile.add_argument("--timeline", help="Resolve timeline name (default: current timeline)")
+    profile.add_argument("--track", type=int, default=1, help="Video track to process")
+    profile.add_argument("--all-tracks", action="store_true", help="Process all video tracks")
+    profile.add_argument("--shot-ids", help="Comma/space-separated shot ids to include")
+    profile.add_argument("--start-from", type=int, default=1, help="1-based clip offset after filters")
+    profile.add_argument("--limit", type=int, default=0, help="Maximum clips to process")
+    profile.add_argument("--continue", dest="continue_run", action="store_true", help="Resume from state")
+    profile.add_argument("--retry-failed", action="store_true", help="Retry failed clips on resume")
+    profile.add_argument("--no-reuse-existing", action="store_true", help="Add a fresh Neat node")
+    profile.add_argument("--no-color-wrap", action="store_true", help="Skip ACES/HDR CST wrapping")
+    profile.add_argument("--state", help="Path to run state JSON")
+    profile.add_argument("--open-timeout", type=float, default=18.0)
+    profile.add_argument("--editor-timeout", type=float, default=60.0)
+    profile.add_argument("--prepare-timeout", type=float, default=1800.0)
+    profile.add_argument("--profile-wait", type=float, default=3.0)
+    profile.add_argument("--ready-timeout", type=float, default=90.0)
+    profile.add_argument("--apply-delay", type=float, default=5.0)
+    profile.add_argument("--close-timeout", type=float, default=20.0)
+    profile.add_argument("--step-delay", type=float, default=1.0)
+    profile.add_argument("--json", action="store_true", help="Print final summary JSON")
+    profile.set_defaults(func=_profile)
+
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    try:
+        return int(args.func(args) or 0)
+    except KeyboardInterrupt:
+        print("Interrupted", file=sys.stderr)
+        return 130
+    except Exception as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

autoneat-0.2.2/src/autoneat/core/__init__.py

@@ -0,0 +1 @@
+"""Engine layer — pure Python, no UI imports."""