artdo-motion-review 0.1.0__tar.gz

artdo_motion_review-0.1.0/.gitignore

@@ -0,0 +1,27 @@
+# Dependencies and local tool state
+node_modules/
+.pnpm-store/
+.DS_Store
+
+# Local environment files
+.env
+.env.*
+!.env.example
+
+# Runtime output is local-only by default: JSON logs, helper scripts, screenshots,
+# browser snapshots, network captures, and lock files all belong here.
+runs/*
+!runs/.gitkeep
+
+# A human may deliberately promote a small, redacted JSON receipt as durable
+# evidence. Promotion is explicit by path, not automatic from a runner.
+!runs/evidence/
+runs/evidence/*
+!runs/evidence/README.md
+!runs/evidence/*.json
+
+# Target-size media exports are reproducible local cache files. Reviewed shared
+# masters under assets/<site>/_shared/v*/ remain tracked. Add one export with
+# `git add -f` only when an exact reviewed file must survive across machines for
+# a registered publishing asset; never force-add the whole export cache.
+assets/**/_shared/exports/

artdo_motion_review-0.1.0/LICENSE

@@ -0,0 +1,4 @@
+LicenseRef-NoLicenseGrant: No package-use license is granted by this preparation.
+The authorized publisher must confirm distribution rights and the intended
+license before any registry upload. No ownership or exclusivity is asserted.
+Original AI-assisted standalone code and documentation are supplied for review.

artdo_motion_review-0.1.0/PKG-INFO

@@ -0,0 +1,46 @@
+Metadata-Version: 2.5
+Name: artdo-motion-review
+Version: 0.1.0
+Summary: Audit timestamped human observations for still-to-motion video candidates locally.
+Project-URL: Homepage, https://artdo.ai/image-to-video
+License-Expression: LicenseRef-NoLicenseGrant
+License-File: LICENSE
+Keywords: manual-audit,motion,video-review
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# artdo-motion-review
+
+A dependency-free Python library and local CLI for summarising timestamped human observations of still-to-motion video candidates. It groups observations by clip, sorts them by time, identifies failed checks and marks each clip as `reviewed`, `pending` or `revise`. It does not read video, inspect pixels, evaluate audio or contact an AI service.
+
+```python
+from artdo_motion_review import audit_observations
+checks = dict(motion="pass", identity="pass", geometry="fail",
+              text="na", continuity="pass", audio="na")
+report = audit_observations([dict(id="note-1", clipId="boat-v1", shotId="wide",
+    atMs=1250, checks=checks, rightsConfirmed=True, note="Fold changes near the bow")])
+assert report["clips"][0]["status"] == "revise"
+```
+
+The example is fictional. Checks and rights confirmation are supplied human assertions, not measurements or legal clearance. `reviewed` describes only the entered observations; it never establishes full temporal coverage, visual quality, consent or fitness for release.
+
+## Input contract
+
+Supply 1–10,000 objects with unique nonempty `id`, `clipId` and `shotId` strings (at most 2,000 input characters). `atMs` must be an actual integer from 0 through 86,400,000; booleans, fractions and negatives are rejected. This bound belongs to the local audit utility, not ArtDo's supported clip lengths. The tool cannot verify that a timestamp exists in an actual clip.
+
+`checks` must have exactly six keys: `motion`, `identity`, `geometry`, `text`, `continuity`, `audio`, with values `pending`, `pass`, `fail` or `na`. `rightsConfirmed` must be an actual boolean. `note` is optional text, limited to 2,000 characters. Other top-level fields are ignored. Any failure yields `revise`; unresolved checks, absent rights confirmation or all-N/A checks yield `pending`. Otherwise an observation is `reviewed`. Clip status uses the most conservative observation status. Inputs are not mutated.
+
+`load_observations(text)` parses JSON and rejects duplicate keys, non-finite constants and malformed/deep nesting. `audit_observations(data)` validates its schema. The CLI reads one local UTF-8 file or stdin, up to 5 MiB, prints JSON and writes no file:
+
+```sh
+artdo-motion-review observations.json
+artdo-motion-review - < observations.json
+```
+
+Valid reports return status 0 even when they contain failures; malformed input returns 1 and argument errors return 2. Python 3.10+ is declared; the actual local test runtime is recorded in the publishing pack. Build/Hatchling/Twine are build tools, not runtime dependencies.
+
+## Product context and provenance
+
+The related [ArtDo image-to-video page](https://artdo.ai/image-to-video) offers an image-and-motion-prompt workflow with model-dependent settings and quoted credits. Check current options in that live product. This utility works independently and provides no generation SDK, private endpoint, model catalogue or guaranteed output. Do not enter private filenames or review notes into a public document without considering their contents.
+
+Original AI-assisted code and documentation; no private product source, credentials or media are included. The included LicenseRef-NoLicenseGrant notice grants no package-use license or ownership assurance. Publisher identity, distribution rights, name/version availability and final upload remain execution checks. Local wheel/sdist preparation creates no PyPI or TestPyPI publication or reservation.

artdo_motion_review-0.1.0/README.md

@@ -0,0 +1,35 @@
+# artdo-motion-review
+
+A dependency-free Python library and local CLI for summarising timestamped human observations of still-to-motion video candidates. It groups observations by clip, sorts them by time, identifies failed checks and marks each clip as `reviewed`, `pending` or `revise`. It does not read video, inspect pixels, evaluate audio or contact an AI service.
+
+```python
+from artdo_motion_review import audit_observations
+checks = dict(motion="pass", identity="pass", geometry="fail",
+              text="na", continuity="pass", audio="na")
+report = audit_observations([dict(id="note-1", clipId="boat-v1", shotId="wide",
+    atMs=1250, checks=checks, rightsConfirmed=True, note="Fold changes near the bow")])
+assert report["clips"][0]["status"] == "revise"
+```
+
+The example is fictional. Checks and rights confirmation are supplied human assertions, not measurements or legal clearance. `reviewed` describes only the entered observations; it never establishes full temporal coverage, visual quality, consent or fitness for release.
+
+## Input contract
+
+Supply 1–10,000 objects with unique nonempty `id`, `clipId` and `shotId` strings (at most 2,000 input characters). `atMs` must be an actual integer from 0 through 86,400,000; booleans, fractions and negatives are rejected. This bound belongs to the local audit utility, not ArtDo's supported clip lengths. The tool cannot verify that a timestamp exists in an actual clip.
+
+`checks` must have exactly six keys: `motion`, `identity`, `geometry`, `text`, `continuity`, `audio`, with values `pending`, `pass`, `fail` or `na`. `rightsConfirmed` must be an actual boolean. `note` is optional text, limited to 2,000 characters. Other top-level fields are ignored. Any failure yields `revise`; unresolved checks, absent rights confirmation or all-N/A checks yield `pending`. Otherwise an observation is `reviewed`. Clip status uses the most conservative observation status. Inputs are not mutated.
+
+`load_observations(text)` parses JSON and rejects duplicate keys, non-finite constants and malformed/deep nesting. `audit_observations(data)` validates its schema. The CLI reads one local UTF-8 file or stdin, up to 5 MiB, prints JSON and writes no file:
+
+```sh
+artdo-motion-review observations.json
+artdo-motion-review - < observations.json
+```
+
+Valid reports return status 0 even when they contain failures; malformed input returns 1 and argument errors return 2. Python 3.10+ is declared; the actual local test runtime is recorded in the publishing pack. Build/Hatchling/Twine are build tools, not runtime dependencies.
+
+## Product context and provenance
+
+The related [ArtDo image-to-video page](https://artdo.ai/image-to-video) offers an image-and-motion-prompt workflow with model-dependent settings and quoted credits. Check current options in that live product. This utility works independently and provides no generation SDK, private endpoint, model catalogue or guaranteed output. Do not enter private filenames or review notes into a public document without considering their contents.
+
+Original AI-assisted code and documentation; no private product source, credentials or media are included. The included LicenseRef-NoLicenseGrant notice grants no package-use license or ownership assurance. Publisher identity, distribution rights, name/version availability and final upload remain execution checks. Local wheel/sdist preparation creates no PyPI or TestPyPI publication or reservation.

artdo_motion_review-0.1.0/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["hatchling>=1.27"]
+build-backend = "hatchling.build"
+
+[project]
+name = "artdo-motion-review"
+version = "0.1.0"
+description = "Audit timestamped human observations for still-to-motion video candidates locally."
+readme = "README.md"
+requires-python = ">=3.10"
+license = "LicenseRef-NoLicenseGrant"
+license-files = ["LICENSE"]
+dependencies = []
+keywords = ["video-review", "motion", "manual-audit"]
+
+[project.urls]
+Homepage = "https://artdo.ai/image-to-video"
+
+[project.scripts]
+artdo-motion-review = "artdo_motion_review:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/artdo_motion_review"]
+
+[tool.hatch.build.targets.sdist]
+include = ["src/", "tests/", "README.md", "LICENSE", "pyproject.toml"]

artdo_motion_review-0.1.0/src/artdo_motion_review/__init__.py

@@ -0,0 +1,97 @@
+"""Local audits of human observations; never reads video or calls a service."""
+import argparse
+import json
+import sys
+
+__version__ = "0.1.0"
+CHECKS = ("motion", "identity", "geometry", "text", "continuity", "audio")
+STATES = ("pending", "pass", "fail", "na")
+
+
+def _text(value, name):
+    if not isinstance(value, str) or not value.strip() or len(value) > 2000:
+        raise ValueError(f"{name} must be nonempty text of at most 2000 characters")
+    return value.strip()
+
+
+def audit_observations(observations):
+    """Validate 1-10000 observations and derive a per-clip human review summary."""
+    if not isinstance(observations, list) or not 1 <= len(observations) <= 10000:
+        raise ValueError("Supply a list of 1 to 10000 observations")
+    groups, seen = {}, set()
+    for index, item in enumerate(observations):
+        if not isinstance(item, dict):
+            raise ValueError(f"Observation {index} must be an object")
+        identifier = _text(item.get("id"), "id")
+        if identifier in seen:
+            raise ValueError(f"Duplicate observation id: {identifier}")
+        seen.add(identifier)
+        clip = _text(item.get("clipId"), "clipId")
+        shot = _text(item.get("shotId"), "shotId")
+        at = item.get("atMs")
+        if type(at) is not int or not 0 <= at <= 86400000:
+            raise ValueError("atMs must be an integer from 0 to 86400000")
+        checks = item.get("checks")
+        if not isinstance(checks, dict) or set(checks) != set(CHECKS):
+            raise ValueError(f"checks must contain exactly {CHECKS}")
+        if any(not isinstance(v, str) or v not in STATES for v in checks.values()):
+            raise ValueError("Invalid check state")
+        rights = item.get("rightsConfirmed")
+        if type(rights) is not bool:
+            raise ValueError("rightsConfirmed must be a boolean")
+        note = item.get("note", "")
+        if not isinstance(note, str) or len(note) > 2000:
+            raise ValueError("note must be text of at most 2000 characters")
+        failed = [name for name in CHECKS if checks[name] == "fail"]
+        unresolved = any(v == "pending" for v in checks.values())
+        status = "revise" if failed else "pending" if unresolved or not rights or "pass" not in checks.values() else "reviewed"
+        groups.setdefault(clip, []).append({"id": identifier, "shotId": shot, "atMs": at,
+                                           "status": status, "failedChecks": failed, "note": note.strip()})
+    clips = []
+    for clip, records in sorted(groups.items()):
+        records.sort(key=lambda r: (r["atMs"], r["id"]))
+        status = "revise" if any(r["status"] == "revise" for r in records) else "pending" if any(r["status"] == "pending" for r in records) else "reviewed"
+        clips.append({"clipId": clip, "status": status, "observations": records})
+    return {"schema": "motion-review-report/v1", "observationCount": len(observations), "clips": clips,
+            "counts": {status: sum(c["status"] == status for c in clips) for status in ("reviewed", "pending", "revise")}}
+
+
+def _unique_keys(pairs):
+    result = {}
+    for key, value in pairs:
+        if key in result:
+            raise ValueError(f"Duplicate JSON key: {key}")
+        result[key] = value
+    return result
+
+
+def load_observations(raw):
+    """Parse strict JSON. The returned value is validated by audit_observations."""
+    try:
+        return json.loads(raw, object_pairs_hook=_unique_keys,
+                          parse_constant=lambda value: (_ for _ in ()).throw(ValueError(f"Invalid JSON constant: {value}")))
+    except (json.JSONDecodeError, RecursionError) as exc:
+        raise ValueError("Invalid or excessively nested JSON") from exc
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(description="Audit local timestamped human video observations")
+    parser.add_argument("file", help="UTF-8 JSON file, or - for stdin")
+    args = parser.parse_args(argv)
+    try:
+        if args.file == "-":
+            raw = sys.stdin.buffer.read(5 * 1024 * 1024 + 1)
+        else:
+            with open(args.file, "rb") as stream:
+                raw = stream.read(5 * 1024 * 1024 + 1)
+        if len(raw) > 5 * 1024 * 1024:
+            raise ValueError("Input exceeds 5 MiB")
+        print(json.dumps(audit_observations(load_observations(raw.decode("utf-8"))), indent=2, ensure_ascii=True))
+        return 0
+    except (ValueError, OSError, UnicodeError) as exc:
+        print(f"motion-review: {exc}", file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

artdo_motion_review-0.1.0/tests/test_review.py

@@ -0,0 +1,43 @@
+import copy
+import unittest
+from artdo_motion_review import audit_observations, load_observations
+
+
+def observation(**changes):
+    result = dict(id="a", clipId="clip", shotId="wide", atMs=1500,
+                  checks=dict(motion="pass", identity="pass", geometry="pass", text="na", continuity="pass", audio="na"),
+                  rightsConfirmed=True)
+    result.update(changes)
+    return result
+
+
+class ReviewTests(unittest.TestCase):
+    def test_group_sort_conservative_and_immutable(self):
+        later = observation()
+        earlier = observation(id="b", atMs=0)
+        earlier["checks"]["geometry"] = "fail"
+        source = [later, earlier, observation(id="c", clipId="other")]
+        before = copy.deepcopy(source)
+        report = audit_observations(source)
+        self.assertEqual(report["counts"], dict(reviewed=1, pending=0, revise=1))
+        self.assertEqual(report["clips"][0]["observations"][0]["failedChecks"], ["geometry"])
+        self.assertEqual(source, before)
+
+    def test_pending_rights_and_all_na(self):
+        for record in [observation(rightsConfirmed=False), observation(checks={k:"na" for k in observation()["checks"]}), observation(checks={k:"pending" for k in observation()["checks"]})]:
+            self.assertEqual(audit_observations([record])["counts"]["pending"], 1)
+
+    def test_bad_inputs(self):
+        for value in [-1, True, 1.2, 86400001, None]:
+            with self.assertRaises(ValueError): audit_observations([observation(atMs=value)])
+        for value in [None, [], [observation(), observation()], [observation(rightsConfirmed="true")], [observation(checks={})], [observation(id=" ")]]:
+            with self.assertRaises(ValueError): audit_observations(value)
+        bad=observation(); bad["checks"]["motion"]=[]
+        with self.assertRaises(ValueError): audit_observations([bad])
+
+    def test_strict_json(self):
+        for raw in ['{"a":1,"a":2}', '[NaN]', '[Infinity]', '[']:
+            with self.assertRaises(ValueError): load_observations(raw)
+
+
+if __name__ == "__main__": unittest.main()