nock-cli 0.0.0__tar.gz → 0.1.0__tar.gz

nock_cli-0.1.0/LICENSE

@@ -0,0 +1,202 @@
+
+                                 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 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
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.

nock_cli-0.1.0/PKG-INFO

@@ -0,0 +1,90 @@
+Metadata-Version: 2.4
+Name: nock-cli
+Version: 0.1.0
+Summary: Open models that live on your machine. Ask questions about your videos, offline.
+Author: NockAI
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://nockai.dev
+Project-URL: Model, https://huggingface.co/Nock-AI/nock-video-4b-GGUF
+Keywords: local,offline,llm,video,llama.cpp,gguf
+Classifier: Environment :: Console
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Multimedia :: Video
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: links
+Requires-Dist: yt-dlp; extra == "links"
+Dynamic: license-file
+
+# Nock CLI
+
+Open models that live on your machine. Ask questions about your videos, offline.
+
+```bash
+nock video summarize my_video.mp4
+nock video ask my_video.mp4 "What error message shows on screen?"
+nock video find my_video.mp4 "when the error message shows up"
+nock video summarize "https://www.youtube.com/watch?v=..."
+```
+
+Everything runs on your computer. Frames are read into a temporary folder, sent to a model running on
+`127.0.0.1`, and deleted when the answer is ready. Nothing is uploaded.
+
+## Install
+
+You need Python 3.9 or newer and [ffmpeg](https://ffmpeg.org/download.html).
+
+```bash
+pipx install nock-cli
+nock setup
+nock doctor
+```
+
+`nock setup` downloads, once:
+- the engine: an official [llama.cpp](https://github.com/ggml-org/llama.cpp) build (about 35 MB; Vulkan on Windows
+  and Linux, Metal on Apple Silicon). Already have `llama-server`? Nock uses it.
+- the model: [Nock Video 4B](https://huggingface.co/Nock-AI/nock-video-4b-GGUF) (about 3.4 GB).
+
+Files go to `~/.nock` (set `NOCK_HOME` to use another folder).
+
+### Links
+
+Links are downloaded to your own machine with [yt-dlp](https://github.com/yt-dlp/yt-dlp), which you install
+yourself:
+
+```bash
+pipx inject nock-cli yt-dlp
+```
+
+Only use videos you have the right to use.
+
+## What to expect
+
+Nock Video 4B is a **preview**. On our test of 20 videos, through llama.cpp at 64 frames, it found the moment in
+42 of 56 questions, answered 56 of 60 questions about what is on screen, and gave 6 of 7 good summaries. Full
+results, including the misses, are on the [model card](https://huggingface.co/Nock-AI/nock-video-4b-GGUF).
+
+- It reads frames only, not sound.
+- A long video is read as at most 64 frames, so short events in long videos can be missed.
+- 64 frames used about 5.5 GB of GPU memory in our test. On GPUs under 6 GB, Nock uses 32 frames (finding the
+  moment drops: 42 to 35 of 56 on our test). `--frames` overrides it.
+- Without a GPU it works, but slowly: minutes per question.
+
+## Options
+
+| Option | Meaning |
+|---|---|
+| `--frames N` | frames to read (default 64, 32 on GPUs under 6 GB) |
+| `nock setup --backend cpu` | CPU-only engine |
+| `NOCK_LLAMA_SERVER=/path/llama-server` | use your own llama.cpp build |
+
+Server logs are in `~/.nock/logs/` if something goes wrong.
+
+## License
+
+Apache-2.0. The model has its own license on its model card (Apache-2.0, from Qwen3.5 4B).

nock_cli-0.1.0/README.md

@@ -0,0 +1,67 @@
+# Nock CLI
+
+Open models that live on your machine. Ask questions about your videos, offline.
+
+```bash
+nock video summarize my_video.mp4
+nock video ask my_video.mp4 "What error message shows on screen?"
+nock video find my_video.mp4 "when the error message shows up"
+nock video summarize "https://www.youtube.com/watch?v=..."
+```
+
+Everything runs on your computer. Frames are read into a temporary folder, sent to a model running on
+`127.0.0.1`, and deleted when the answer is ready. Nothing is uploaded.
+
+## Install
+
+You need Python 3.9 or newer and [ffmpeg](https://ffmpeg.org/download.html).
+
+```bash
+pipx install nock-cli
+nock setup
+nock doctor
+```
+
+`nock setup` downloads, once:
+- the engine: an official [llama.cpp](https://github.com/ggml-org/llama.cpp) build (about 35 MB; Vulkan on Windows
+  and Linux, Metal on Apple Silicon). Already have `llama-server`? Nock uses it.
+- the model: [Nock Video 4B](https://huggingface.co/Nock-AI/nock-video-4b-GGUF) (about 3.4 GB).
+
+Files go to `~/.nock` (set `NOCK_HOME` to use another folder).
+
+### Links
+
+Links are downloaded to your own machine with [yt-dlp](https://github.com/yt-dlp/yt-dlp), which you install
+yourself:
+
+```bash
+pipx inject nock-cli yt-dlp
+```
+
+Only use videos you have the right to use.
+
+## What to expect
+
+Nock Video 4B is a **preview**. On our test of 20 videos, through llama.cpp at 64 frames, it found the moment in
+42 of 56 questions, answered 56 of 60 questions about what is on screen, and gave 6 of 7 good summaries. Full
+results, including the misses, are on the [model card](https://huggingface.co/Nock-AI/nock-video-4b-GGUF).
+
+- It reads frames only, not sound.
+- A long video is read as at most 64 frames, so short events in long videos can be missed.
+- 64 frames used about 5.5 GB of GPU memory in our test. On GPUs under 6 GB, Nock uses 32 frames (finding the
+  moment drops: 42 to 35 of 56 on our test). `--frames` overrides it.
+- Without a GPU it works, but slowly: minutes per question.
+
+## Options
+
+| Option | Meaning |
+|---|---|
+| `--frames N` | frames to read (default 64, 32 on GPUs under 6 GB) |
+| `nock setup --backend cpu` | CPU-only engine |
+| `NOCK_LLAMA_SERVER=/path/llama-server` | use your own llama.cpp build |
+
+Server logs are in `~/.nock/logs/` if something goes wrong.
+
+## License
+
+Apache-2.0. The model has its own license on its model card (Apache-2.0, from Qwen3.5 4B).

nock_cli-0.1.0/pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = ["setuptools>=69"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "nock-cli"
+version = "0.1.0"
+description = "Open models that live on your machine. Ask questions about your videos, offline."
+readme = "README.md"
+requires-python = ">=3.9"
+license = "Apache-2.0"
+authors = [{ name = "NockAI" }]
+keywords = ["local", "offline", "llm", "video", "llama.cpp", "gguf"]
+classifiers = [
+  "Environment :: Console",
+  "Operating System :: Microsoft :: Windows",
+  "Operating System :: POSIX :: Linux",
+  "Operating System :: MacOS",
+  "Programming Language :: Python :: 3",
+  "Topic :: Multimedia :: Video",
+  "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+# No required dependencies: the standard library only. yt-dlp is optional, for links.
+dependencies = []
+
+[project.optional-dependencies]
+links = ["yt-dlp"]
+
+[project.urls]
+Homepage = "https://nockai.dev"
+Model = "https://huggingface.co/Nock-AI/nock-video-4b-GGUF"
+
+[project.scripts]
+nock = "nock_cli.main:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]

nock_cli-0.1.0/setup.cfg

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

nock_cli-0.1.0/src/nock_cli/__init__.py

@@ -0,0 +1,3 @@
+"""Nock CLI: open models that live on your machine."""
+
+__version__ = "0.1.0"

nock_cli-0.1.0/src/nock_cli/__main__.py

@@ -0,0 +1,3 @@
+from nock_cli.main import main
+
+main()

nock_cli-0.1.0/src/nock_cli/download.py

@@ -0,0 +1,54 @@
+"""Plain HTTPS downloads with a progress line and resume, using only the standard library."""
+
+import json
+import sys
+import urllib.request
+from pathlib import Path
+
+USER_AGENT = "nock-cli"
+CHUNK_SIZE = 1024 * 1024
+
+
+def get_json(url):
+  request = urllib.request.Request(url, headers={"User-Agent": USER_AGENT, "Accept": "application/json"})
+  with urllib.request.urlopen(request, timeout=60) as response:
+    return json.load(response)
+
+
+def download(url, target, label):
+  """Downloads `url` to `target`. A partial `.part` file from an earlier try is resumed, not started over."""
+  target = Path(target)
+  if target.exists():
+    return target
+  target.parent.mkdir(parents=True, exist_ok=True)
+  partial = target.with_name(target.name + ".part")
+  done = partial.stat().st_size if partial.exists() else 0
+  headers = {"User-Agent": USER_AGENT}
+  if done:
+    headers["Range"] = f"bytes={done}-"
+  request = urllib.request.Request(url, headers=headers)
+  with urllib.request.urlopen(request, timeout=60) as response:
+    # 206 means the server honoured the range; anything else sends the whole file again.
+    if done and response.status != 206:
+      done = 0
+    total = done + int(response.headers.get("Content-Length") or 0)
+    with open(partial, "ab" if done else "wb") as handle:
+      while True:
+        chunk = response.read(CHUNK_SIZE)
+        if not chunk:
+          break
+        handle.write(chunk)
+        done += len(chunk)
+        show_progress(label, done, total)
+  sys.stderr.write("\n")
+  partial.replace(target)
+  return target
+
+
+def show_progress(label, done, total):
+  megabytes = done / 1048576
+  if total:
+    sys.stderr.write(f"\r  {label}: {megabytes:,.0f} / {total / 1048576:,.0f} MB ({done * 100 // total}%)")
+  else:
+    sys.stderr.write(f"\r  {label}: {megabytes:,.0f} MB")
+  sys.stderr.flush()

nock_cli-0.1.0/src/nock_cli/engine.py

@@ -0,0 +1,180 @@
+"""The engine: an official llama.cpp build (llama-server), downloaded once by `nock setup` and run on 127.0.0.1 only.
+
+Nock does not bundle llama.cpp. It fetches a pinned release from github.com/ggml-org/llama.cpp so every user runs
+the same tested build. An existing llama-server can be used instead (NOCK_LLAMA_SERVER, or on the PATH).
+"""
+
+import os
+import platform
+import shutil
+import socket
+import subprocess
+import tarfile
+import time
+import urllib.error
+import urllib.request
+import zipfile
+from pathlib import Path
+
+from nock_cli import paths
+from nock_cli.download import download
+
+LLAMA_CPP_BUILD = "b11804"
+RELEASE_URL = f"https://github.com/ggml-org/llama.cpp/releases/download/{LLAMA_CPP_BUILD}"
+
+# Vulkan is the default on Windows and Linux: one small build (about 35 MB) that runs on NVIDIA, AMD and Intel GPUs.
+# Macs use Metal, which is built into the macOS release.
+ASSETS = {
+  ("windows", "x64", "vulkan"): "llama-{build}-bin-win-vulkan-x64.zip",
+  ("windows", "x64", "cpu"): "llama-{build}-bin-win-cpu-x64.zip",
+  ("windows", "arm64", "vulkan"): "llama-{build}-bin-win-vulkan-arm64.zip",
+  ("windows", "arm64", "cpu"): "llama-{build}-bin-win-cpu-arm64.zip",
+  ("linux", "x64", "vulkan"): "llama-{build}-bin-ubuntu-vulkan-x64.tar.gz",
+  ("linux", "x64", "cpu"): "llama-{build}-bin-ubuntu-x64.tar.gz",
+  ("linux", "arm64", "vulkan"): "llama-{build}-bin-ubuntu-vulkan-arm64.tar.gz",
+  ("linux", "arm64", "cpu"): "llama-{build}-bin-ubuntu-arm64.tar.gz",
+  ("macos", "arm64", "metal"): "llama-{build}-bin-macos-arm64.tar.gz",
+  ("macos", "x64", "cpu"): "llama-{build}-bin-macos-x64.tar.gz",
+}
+BACKENDS = ("vulkan", "cpu", "metal")
+SERVER_START_TIMEOUT = 300  # loading 3.4 GB from a slow disk can take a while
+
+
+class EngineError(Exception):
+  pass
+
+
+def current_system():
+  system = {"Windows": "windows", "Linux": "linux", "Darwin": "macos"}.get(platform.system())
+  machine = platform.machine().lower()
+  arch = "arm64" if machine in ("arm64", "aarch64") else "x64" if machine in ("amd64", "x86_64", "x64") else machine
+  return system, arch
+
+
+def default_backend(system, arch):
+  if system == "macos":
+    return "metal" if arch == "arm64" else "cpu"
+  return "vulkan"
+
+
+def asset_name(system, arch, backend):
+  template = ASSETS.get((system, arch, backend))
+  if not template:
+    supported = ", ".join(f"{s}/{a}/{b}" for s, a, b in ASSETS)
+    raise EngineError(f"No llama.cpp build for {system}/{arch}/{backend}. Supported: {supported}")
+  return template.format(build=LLAMA_CPP_BUILD)
+
+
+def server_binary_name():
+  return "llama-server.exe" if platform.system() == "Windows" else "llama-server"
+
+
+def find_server_in(folder):
+  matches = sorted(Path(folder).rglob(server_binary_name()))
+  return matches[0] if matches else None
+
+
+def install(backend=None):
+  """Downloads and unpacks the pinned llama.cpp build. Returns the path to llama-server."""
+  system, arch = current_system()
+  backend = backend or default_backend(system, arch)
+  name = asset_name(system, arch, backend)
+  target = paths.engine_dir() / f"{LLAMA_CPP_BUILD}-{backend}"
+  existing = find_server_in(target) if target.exists() else None
+  if existing:
+    return existing
+  archive = download(f"{RELEASE_URL}/{name}", paths.engine_dir() / "downloads" / name, f"llama.cpp {LLAMA_CPP_BUILD} ({backend})")
+  target.mkdir(parents=True, exist_ok=True)
+  unpack(archive, target)
+  server = find_server_in(target)
+  if not server:
+    raise EngineError(f"{name} did not contain {server_binary_name()}")
+  if platform.system() != "Windows":
+    server.chmod(0o755)
+  archive.unlink()
+  return server
+
+
+def unpack(archive, target):
+  target = Path(target).resolve()
+  if archive.name.endswith(".zip"):
+    with zipfile.ZipFile(archive) as bundle:
+      for member in bundle.namelist():
+        ensure_inside(target, member)
+      bundle.extractall(target)
+  else:
+    with tarfile.open(archive) as bundle:
+      for member in bundle.getmembers():
+        ensure_inside(target, member.name)
+        if member.issym() or member.islnk():
+          ensure_inside(target, os.path.join(os.path.dirname(member.name), member.linkname))
+      bundle.extractall(target)
+
+
+def ensure_inside(target, member_name):
+  """Refuses archive entries that would land outside the engine folder."""
+  resolved = (target / member_name).resolve()
+  if resolved != target and target not in resolved.parents:
+    raise EngineError(f"Unsafe path in archive: {member_name}")
+
+
+def locate_server(settings):
+  """The llama-server to use: NOCK_LLAMA_SERVER, then the one `nock setup` installed, then one on the PATH."""
+  override = os.environ.get("NOCK_LLAMA_SERVER")
+  if override:
+    return Path(override)
+  installed = settings.get("llama_server")
+  if installed and Path(installed).exists():
+    return Path(installed)
+  on_path = shutil.which("llama-server")
+  return Path(on_path) if on_path else None
+
+
+def free_port():
+  with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as probe:
+    probe.bind(("127.0.0.1", 0))
+    return probe.getsockname()[1]
+
+
+class LocalServer:
+  """Runs llama-server for one command and stops it afterwards. It listens on 127.0.0.1 only."""
+
+  def __init__(self, server_binary, model_path, mmproj_path, context, gpu_layers, log_path):
+    self.port = free_port()
+    self.url = f"http://127.0.0.1:{self.port}"
+    self.command = [str(server_binary), "-m", str(model_path), "--mmproj", str(mmproj_path), "--jinja",
+                    "-c", str(context), "-ngl", str(gpu_layers), "--host", "127.0.0.1", "--port", str(self.port)]
+    self.log_path = Path(log_path)
+    self.process = None
+    self.log_handle = None
+
+  def __enter__(self):
+    self.log_path.parent.mkdir(parents=True, exist_ok=True)
+    self.log_handle = open(self.log_path, "w", encoding="utf-8", errors="replace")
+    self.process = subprocess.Popen(self.command, stdout=self.log_handle, stderr=subprocess.STDOUT)
+    self.wait_until_ready()
+    return self
+
+  def __exit__(self, *exc_info):
+    if self.process and self.process.poll() is None:
+      self.process.terminate()
+      try:
+        self.process.wait(timeout=15)
+      except subprocess.TimeoutExpired:
+        self.process.kill()
+    if self.log_handle:
+      self.log_handle.close()
+
+  def wait_until_ready(self):
+    deadline = time.time() + SERVER_START_TIMEOUT
+    while time.time() < deadline:
+      if self.process.poll() is not None:
+        raise EngineError(f"llama-server stopped while loading the model. Log: {self.log_path}")
+      try:
+        with urllib.request.urlopen(f"{self.url}/health", timeout=5) as response:
+          if response.status == 200:
+            return
+      except (urllib.error.URLError, ConnectionError, OSError):
+        pass  # still loading: /health answers 503 or refuses the connection until the model is in memory
+      time.sleep(1)
+    raise EngineError(f"llama-server was not ready after {SERVER_START_TIMEOUT} s. Log: {self.log_path}")

nock_cli-0.1.0/src/nock_cli/main.py

@@ -0,0 +1,124 @@
+"""Command line entry point: `nock setup`, `nock doctor`, `nock video ...`."""
+
+import argparse
+import shutil
+import subprocess
+import sys
+import urllib.error
+
+from nock_cli import __version__, engine, models, paths, video
+
+SKILLS = sorted(models.MODELS)
+
+
+def command_setup(args):
+  settings = paths.load_settings()
+  print(f"Nock home: {paths.nock_home()}")
+  existing = engine.locate_server(settings)
+  if existing and not args.backend:
+    print(f"Engine: {existing} (nock setup --backend vulkan|cpu|metal installs Nock's own build)")
+  else:
+    print("Installing the engine (llama.cpp, from github.com/ggml-org/llama.cpp)...")
+    settings["llama_server"] = str(engine.install(args.backend))
+    settings["llama_cpp_build"] = engine.LLAMA_CPP_BUILD
+  for skill in args.skills or SKILLS:
+    spec = models.MODELS[skill]
+    print(f"Downloading {spec['title']} from huggingface.co/{spec['repo']}...")
+    settings.setdefault("models", {})[skill] = models.install(skill)
+  paths.save_settings(settings)
+  print("Ready. Try: nock video summarize my_video.mp4")
+
+
+def check(label, ok, detail):
+  print(f"  [{'ok' if ok else '--'}] {label}: {detail}")
+  return ok
+
+
+def command_doctor(args):
+  settings = paths.load_settings()
+  print(f"nock {__version__}, home {paths.nock_home()}")
+  server = engine.locate_server(settings)
+  ready = check("engine", bool(server), server or "missing: run `nock setup`")
+  ready &= check("ffmpeg", bool(shutil.which("ffmpeg") and shutil.which("ffprobe")),
+                 shutil.which("ffmpeg") or "missing: install ffmpeg (https://ffmpeg.org/download.html)")
+  check("yt-dlp (optional, for links)", bool(shutil.which("yt-dlp")), shutil.which("yt-dlp") or "not installed: pipx inject nock-cli yt-dlp")
+  for skill in SKILLS:
+    installed = settings.get("models", {}).get(skill)
+    ready &= check(f"model {skill}", bool(installed), f"{installed['repo']}@{installed['revision'][:7]}" if installed else "missing: run `nock setup`")
+  memory = video.gpu_memory_mb()
+  check("NVIDIA GPU", memory is not None,
+        f"{memory} MB" if memory is not None else "not found (other GPUs work through Vulkan or Metal; CPU only is slow)")
+  free_gb = shutil.disk_usage(paths.nock_home().anchor or "/").free / 1e9
+  check("free disk", free_gb > 5, f"{free_gb:.0f} GB (setup needs about 4 GB)")
+  return 0 if ready else 1
+
+
+def start_server_factory(skill):
+  settings = paths.load_settings()
+  server_binary = engine.locate_server(settings)
+  installed = settings.get("models", {}).get(skill)
+  if not server_binary or not installed:
+    sys.exit("Nock is not set up yet. Run: nock setup")
+  log_path = paths.nock_home() / "logs" / f"{skill}-server.log"
+
+  def start(context):
+    return engine.LocalServer(server_binary, installed["model"], installed["mmproj"], context, 99, log_path)
+
+  return start
+
+
+def command_video(args):
+  kind = {"summarize": "summary", "ask": "ask", "find": "moment"}[args.action]
+  question = video.SUMMARY_QUESTION if kind == "summary" else args.question
+  frames = video.choose_frames(args.frames)
+  answer = video.run(args.source, question, kind, frames, start_server_factory("video"))
+  print(answer)
+
+
+def build_parser():
+  parser = argparse.ArgumentParser(prog="nock", description="Open models that live on your machine.")
+  parser.add_argument("--version", action="version", version=f"nock {__version__}")
+  commands = parser.add_subparsers(dest="command", required=True)
+
+  setup = commands.add_parser("setup", help="download the engine and the models (once)")
+  setup.add_argument("skills", nargs="*", choices=SKILLS, help="which models (default: all)")
+  setup.add_argument("--backend", choices=engine.BACKENDS, help="llama.cpp build: vulkan (default), cpu, metal (Mac)")
+  setup.set_defaults(handler=command_setup)
+
+  doctor = commands.add_parser("doctor", help="check that everything is in place")
+  doctor.set_defaults(handler=command_doctor)
+
+  video_parser = commands.add_parser("video", help="ask about a video file or link, offline")
+  actions = video_parser.add_subparsers(dest="action", required=True)
+  summarize = actions.add_parser("summarize", help="a few short points about the video")
+  summarize.add_argument("source", help="video file or link")
+  ask = actions.add_parser("ask", help="a question about what the video shows")
+  ask.add_argument("source", help="video file or link")
+  ask.add_argument("question")
+  find = actions.add_parser("find", help="when does something happen")
+  find.add_argument("source", help="video file or link")
+  find.add_argument("question", help='what to find, for example "the error message shows up"')
+  for action in (summarize, ask, find):
+    action.add_argument("--frames", type=int, help=f"frames to read (default {video.MAX_FRAMES}, "
+                                                   f"{video.LOW_MEMORY_FRAMES} on GPUs under 6 GB)")
+  video_parser.set_defaults(handler=command_video)
+  return parser
+
+
+def main(argv=None):
+  args = build_parser().parse_args(argv)
+  try:
+    result = args.handler(args)
+  except KeyboardInterrupt:
+    sys.exit("Stopped.")
+  except (engine.EngineError, models.ModelError, video.VideoError) as error:
+    sys.exit(f"nock: {error}")
+  except subprocess.CalledProcessError as error:
+    sys.exit(f"nock: {error.cmd[0]} failed (exit code {error.returncode})")
+  except urllib.error.URLError as error:
+    sys.exit(f"nock: network error: {error.reason}")
+  sys.exit(result or 0)
+
+
+if __name__ == "__main__":
+  main()

nock_cli-0.1.0/src/nock_cli/models.py

@@ -0,0 +1,42 @@
+"""Model files from Hugging Face. The file names are read from the repo, so a new release needs no CLI update."""
+
+import fnmatch
+
+from nock_cli import paths
+from nock_cli.download import download, get_json
+
+MODELS = {
+  "video": {
+    "repo": "Nock-AI/nock-video-4b-GGUF",
+    "title": "Nock Video 4B",
+    "model_pattern": "*Q4_K_M.gguf",
+    "mmproj_pattern": "mmproj*.gguf",
+  },
+}
+
+
+class ModelError(Exception):
+  pass
+
+
+def pick_file(files, pattern, exclude_pattern=None):
+  matches = [name for name in files if fnmatch.fnmatch(name, pattern)
+             and not (exclude_pattern and fnmatch.fnmatch(name, exclude_pattern))]
+  if len(matches) != 1:
+    raise ModelError(f"Expected one file matching {pattern}, found {matches or 'none'}")
+  return matches[0]
+
+
+def install(skill):
+  """Downloads the model and its vision projector into ~/.nock/models/<skill>/<revision>/."""
+  spec = MODELS[skill]
+  info = get_json(f"https://huggingface.co/api/models/{spec['repo']}")
+  revision = info["sha"]
+  files = [entry["rfilename"] for entry in info.get("siblings", [])]
+  model_file = pick_file(files, spec["model_pattern"], exclude_pattern=spec["mmproj_pattern"])
+  mmproj_file = pick_file(files, spec["mmproj_pattern"])
+  folder = paths.models_dir() / skill / revision[:7]
+  base = f"https://huggingface.co/{spec['repo']}/resolve/{revision}"
+  model_path = download(f"{base}/{model_file}", folder / model_file, model_file)
+  mmproj_path = download(f"{base}/{mmproj_file}", folder / mmproj_file, mmproj_file)
+  return {"repo": spec["repo"], "revision": revision, "model": str(model_path), "mmproj": str(mmproj_path)}

nock_cli-0.1.0/src/nock_cli/paths.py

@@ -0,0 +1,38 @@
+"""Where Nock keeps its files, and the small settings file that remembers what `nock setup` installed."""
+
+import json
+import os
+from pathlib import Path
+
+
+def nock_home():
+  """~/.nock by default; NOCK_HOME moves everything (for example to a bigger drive)."""
+  return Path(os.environ.get("NOCK_HOME") or Path.home() / ".nock")
+
+
+def engine_dir():
+  return nock_home() / "engine"
+
+
+def models_dir():
+  return nock_home() / "models"
+
+
+def settings_path():
+  return nock_home() / "settings.json"
+
+
+def load_settings():
+  path = settings_path()
+  if not path.exists():
+    return {}
+  try:
+    return json.loads(path.read_text(encoding="utf-8"))
+  except (OSError, ValueError):
+    return {}
+
+
+def save_settings(settings):
+  path = settings_path()
+  path.parent.mkdir(parents=True, exist_ok=True)
+  path.write_text(json.dumps(settings, indent=2), encoding="utf-8")

nock_cli-0.1.0/src/nock_cli/video.py

@@ -0,0 +1,182 @@
+"""Nock Video: summarize a video, ask about it, or find a moment, offline.
+
+The input matches the setup our published scores were measured with: up to 64 frames (1 per second for short
+videos), 768 px wide, each labelled "Frame at N s:", then the question and a fixed instruction, greedy decoding,
+thinking off. The frames are written to a temporary folder and deleted afterwards.
+"""
+
+import base64
+import json
+import math
+import re
+import shutil
+import subprocess
+import sys
+import tempfile
+import urllib.request
+from pathlib import Path
+
+MAX_FRAMES = 64
+LOW_MEMORY_FRAMES = 32
+FRAME_WIDTH = 768
+SMALL_GPU_MB = 6000  # 64 frames peaked at 5.5 GB on the GPU in our test, so smaller cards start at 32
+PREAMBLE = "These are frames from one video, in order. Each frame is labeled with its time in seconds."
+INSTRUCTIONS = {
+  "moment": "Give the whole stretch of time when this is happening, from the first frame where it starts to the last "
+            "frame where it is still visible. Answer only with START-END in seconds.",
+  "ask": "Answer in one short sentence.",
+  "summary": "Answer with 3 to 5 short bullet points. Only include what the video shows.",
+}
+MAX_TOKENS = {"moment": 32, "ask": 64, "summary": 256}
+SUMMARY_QUESTION = "Summarize this video in a few short points."
+REQUEST_TIMEOUT = 1800  # CPU-only machines can take many minutes for 64 frames
+
+
+class VideoError(Exception):
+  pass
+
+
+def is_link(source):
+  return re.match(r"^https?://", source, re.IGNORECASE) is not None
+
+
+def require_tool(name, hint):
+  if not shutil.which(name):
+    raise VideoError(f"{name} was not found on the PATH. {hint}")
+
+
+def fetch_link(url, folder):
+  """Downloads a link to this machine with yt-dlp, which the user installs themselves (pipx inject nock-cli yt-dlp)."""
+  command = [shutil.which("yt-dlp")] if shutil.which("yt-dlp") else None
+  if not command:
+    try:
+      import yt_dlp  # noqa: F401  (only checks that the module is there)
+      command = [sys.executable, "-m", "yt_dlp"]
+    except ImportError:
+      raise VideoError("Links need yt-dlp. Install it with: pipx inject nock-cli yt-dlp  (or: pip install yt-dlp)")
+  print("Downloading the video to this machine with yt-dlp. Only use videos you have the right to use.", file=sys.stderr)
+  template = str(Path(folder) / "video.%(ext)s")
+  # 720p is plenty: frames are scaled to 768 px wide anyway. Audio is not used.
+  subprocess.run(command + ["-q", "--no-playlist", "-f", "bv*[height<=720]/b[height<=720]/bv*/b", "-o", template, url], check=True)
+  downloaded = [path for path in Path(folder).glob("video.*") if path.suffix != ".part"]
+  if not downloaded:
+    raise VideoError("yt-dlp finished but no video file was written")
+  return downloaded[0]
+
+
+def video_duration(path):
+  output = subprocess.run(["ffprobe", "-v", "error", "-show_entries", "format=duration", "-of", "csv=p=0", str(path)],
+                          capture_output=True, text=True)
+  try:
+    return float(output.stdout.strip())
+  except ValueError:
+    raise VideoError(f"Could not read the length of {path}. Is it a video file?")
+
+
+def frame_times(duration, max_frames=MAX_FRAMES):
+  """Evenly spaced frame times: 1 per second for short videos, at most max_frames for long ones."""
+  count = min(max_frames, max(1, math.ceil(duration)))
+  return [round((index + 0.5) * duration / count, 1) for index in range(count)]
+
+
+def extract_frames(video, folder, max_frames):
+  # 0.2 s off the end: some files report a length a little past their last frame.
+  duration = max(0.5, video_duration(video) - 0.2)
+  frames = []
+  for index, seconds in enumerate(frame_times(duration, max_frames)):
+    path = Path(folder) / f"{index:03d}.jpg"
+    subprocess.run(["ffmpeg", "-loglevel", "error", "-y", "-ss", str(seconds), "-i", str(video), "-frames:v", "1",
+                    "-vf", f"scale={FRAME_WIDTH}:-2", "-q:v", "3", str(path)], check=True)
+    frames.append((seconds, path))
+  return frames
+
+
+def build_request(frames, question, kind):
+  content = [{"type": "text", "text": PREAMBLE}]
+  for seconds, path in frames:
+    encoded = base64.b64encode(Path(path).read_bytes()).decode()
+    content.append({"type": "text", "text": f"Frame at {seconds} s:"})
+    content.append({"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{encoded}"}})
+  content.append({"type": "text", "text": f"{question} {INSTRUCTIONS[kind]}"})
+  return {"messages": [{"role": "user", "content": content}], "temperature": 0, "max_tokens": MAX_TOKENS[kind],
+          "chat_template_kwargs": {"enable_thinking": False}}
+
+
+def ask_server(server_url, body):
+  request = urllib.request.Request(f"{server_url}/v1/chat/completions", data=json.dumps(body).encode(),
+                                   headers={"Content-Type": "application/json"})
+  with urllib.request.urlopen(request, timeout=REQUEST_TIMEOUT) as response:
+    return json.load(response)["choices"][0]["message"]["content"].strip()
+
+
+def parse_span(text):
+  """First two numbers (seconds, or m:ss) in the answer, as a (start, end) pair."""
+  values = []
+  for match in re.finditer(r"(\d+):(\d{1,2}(?:\.\d+)?)|(\d+(?:\.\d+)?)", text):
+    values.append(int(match.group(1)) * 60 + float(match.group(2)) if match.group(1) else float(match.group(3)))
+    if len(values) == 2:
+      break
+  if len(values) < 2:
+    return None
+  start, end = sorted(values)
+  return start, end
+
+
+def clock(seconds):
+  seconds = int(round(seconds))
+  hours, rest = divmod(seconds, 3600)
+  minutes, secs = divmod(rest, 60)
+  return f"{hours}:{minutes:02d}:{secs:02d}" if hours else f"{minutes}:{secs:02d}"
+
+
+def format_answer(kind, answer):
+  if kind != "moment":
+    return answer
+  span = parse_span(answer)
+  if not span:
+    return f"No clear moment found. The model answered: {answer}"
+  return f"{clock(span[0])} to {clock(span[1])}  ({span[0]:g}-{span[1]:g} s)"
+
+
+def gpu_memory_mb():
+  """Total memory of the first NVIDIA GPU, or None when nvidia-smi is not there (other GPUs are not measured)."""
+  if not shutil.which("nvidia-smi"):
+    return None
+  output = subprocess.run(["nvidia-smi", "--query-gpu=memory.total", "--format=csv,noheader,nounits"],
+                          capture_output=True, text=True)
+  try:
+    return int(output.stdout.strip().splitlines()[0])
+  except (ValueError, IndexError):
+    return None
+
+
+def choose_frames(requested):
+  if requested:
+    return requested
+  memory = gpu_memory_mb()
+  if memory is not None and memory < SMALL_GPU_MB:
+    print(f"GPU has {memory} MB: using {LOW_MEMORY_FRAMES} frames (less accurate at finding moments; "
+          f"--frames {MAX_FRAMES} to override).", file=sys.stderr)
+    return LOW_MEMORY_FRAMES
+  return MAX_FRAMES
+
+
+def context_for(frame_count):
+  # 64 frames took about 22K prompt tokens in our test; leave room for the answer.
+  return 32768 if frame_count > LOW_MEMORY_FRAMES else 16384
+
+
+def run(source, question, kind, frame_count, start_server):
+  """start_server(context) returns a context manager with a .url; it is started only after the frames are ready."""
+  require_tool("ffmpeg", "Install ffmpeg (https://ffmpeg.org/download.html), then try again. Run `nock doctor` to check.")
+  require_tool("ffprobe", "ffprobe comes with ffmpeg. Run `nock doctor` to check.")
+  with tempfile.TemporaryDirectory(prefix="nock-") as folder:
+    video = fetch_link(source, folder) if is_link(source) else Path(source)
+    if not video.exists():
+      raise VideoError(f"File not found: {video}")
+    frames = extract_frames(video, folder, frame_count)
+    print(f"Read {len(frames)} frames.", file=sys.stderr)
+    body = build_request(frames, question, kind)
+    with start_server(context_for(frame_count)) as server:
+      print("Thinking...", file=sys.stderr)
+      return format_answer(kind, ask_server(server.url, body))

nock_cli-0.1.0/src/nock_cli.egg-info/PKG-INFO

@@ -0,0 +1,90 @@
+Metadata-Version: 2.4
+Name: nock-cli
+Version: 0.1.0
+Summary: Open models that live on your machine. Ask questions about your videos, offline.
+Author: NockAI
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://nockai.dev
+Project-URL: Model, https://huggingface.co/Nock-AI/nock-video-4b-GGUF
+Keywords: local,offline,llm,video,llama.cpp,gguf
+Classifier: Environment :: Console
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Multimedia :: Video
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: links
+Requires-Dist: yt-dlp; extra == "links"
+Dynamic: license-file
+
+# Nock CLI
+
+Open models that live on your machine. Ask questions about your videos, offline.
+
+```bash
+nock video summarize my_video.mp4
+nock video ask my_video.mp4 "What error message shows on screen?"
+nock video find my_video.mp4 "when the error message shows up"
+nock video summarize "https://www.youtube.com/watch?v=..."
+```
+
+Everything runs on your computer. Frames are read into a temporary folder, sent to a model running on
+`127.0.0.1`, and deleted when the answer is ready. Nothing is uploaded.
+
+## Install
+
+You need Python 3.9 or newer and [ffmpeg](https://ffmpeg.org/download.html).
+
+```bash
+pipx install nock-cli
+nock setup
+nock doctor
+```
+
+`nock setup` downloads, once:
+- the engine: an official [llama.cpp](https://github.com/ggml-org/llama.cpp) build (about 35 MB; Vulkan on Windows
+  and Linux, Metal on Apple Silicon). Already have `llama-server`? Nock uses it.
+- the model: [Nock Video 4B](https://huggingface.co/Nock-AI/nock-video-4b-GGUF) (about 3.4 GB).
+
+Files go to `~/.nock` (set `NOCK_HOME` to use another folder).
+
+### Links
+
+Links are downloaded to your own machine with [yt-dlp](https://github.com/yt-dlp/yt-dlp), which you install
+yourself:
+
+```bash
+pipx inject nock-cli yt-dlp
+```
+
+Only use videos you have the right to use.
+
+## What to expect
+
+Nock Video 4B is a **preview**. On our test of 20 videos, through llama.cpp at 64 frames, it found the moment in
+42 of 56 questions, answered 56 of 60 questions about what is on screen, and gave 6 of 7 good summaries. Full
+results, including the misses, are on the [model card](https://huggingface.co/Nock-AI/nock-video-4b-GGUF).
+
+- It reads frames only, not sound.
+- A long video is read as at most 64 frames, so short events in long videos can be missed.
+- 64 frames used about 5.5 GB of GPU memory in our test. On GPUs under 6 GB, Nock uses 32 frames (finding the
+  moment drops: 42 to 35 of 56 on our test). `--frames` overrides it.
+- Without a GPU it works, but slowly: minutes per question.
+
+## Options
+
+| Option | Meaning |
+|---|---|
+| `--frames N` | frames to read (default 64, 32 on GPUs under 6 GB) |
+| `nock setup --backend cpu` | CPU-only engine |
+| `NOCK_LLAMA_SERVER=/path/llama-server` | use your own llama.cpp build |
+
+Server logs are in `~/.nock/logs/` if something goes wrong.
+
+## License
+
+Apache-2.0. The model has its own license on its model card (Apache-2.0, from Qwen3.5 4B).

nock_cli-0.1.0/src/nock_cli.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+LICENSE
+README.md
+pyproject.toml
+src/nock_cli/__init__.py
+src/nock_cli/__main__.py
+src/nock_cli/download.py
+src/nock_cli/engine.py
+src/nock_cli/main.py
+src/nock_cli/models.py
+src/nock_cli/paths.py
+src/nock_cli/video.py
+src/nock_cli.egg-info/PKG-INFO
+src/nock_cli.egg-info/SOURCES.txt
+src/nock_cli.egg-info/dependency_links.txt
+src/nock_cli.egg-info/entry_points.txt
+src/nock_cli.egg-info/requires.txt
+src/nock_cli.egg-info/top_level.txt
+tests/test_cli.py

nock_cli-0.1.0/src/nock_cli.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

nock_cli-0.1.0/src/nock_cli.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+nock = nock_cli.main:main

nock_cli-0.1.0/src/nock_cli.egg-info/requires.txt

@@ -0,0 +1,3 @@
+
+[links]
+yt-dlp

nock_cli-0.1.0/src/nock_cli.egg-info/top_level.txt

@@ -0,0 +1 @@
+nock_cli

nock_cli-0.1.0/tests/test_cli.py

@@ -0,0 +1,101 @@
+"""Fast checks that need no model, GPU or network: python -m unittest discover -s tests"""
+
+import io
+import tarfile
+import tempfile
+import unittest
+import zipfile
+from pathlib import Path
+
+from nock_cli import engine, main, models, video
+
+
+class FrameTimesTest(unittest.TestCase):
+  def test_short_video_gets_one_frame_per_second(self):
+    self.assertEqual(video.frame_times(4.0), [0.5, 1.5, 2.5, 3.5])
+
+  def test_long_video_is_capped(self):
+    times = video.frame_times(600.0, max_frames=64)
+    self.assertEqual(len(times), 64)
+    self.assertLess(times[-1], 600.0)
+
+
+class ParseSpanTest(unittest.TestCase):
+  def test_seconds(self):
+    self.assertEqual(video.parse_span("12-20"), (12.0, 20.0))
+
+  def test_minutes_and_reversed(self):
+    self.assertEqual(video.parse_span("from 1:30 to 0:45"), (45.0, 90.0))
+
+  def test_no_span(self):
+    self.assertIsNone(video.parse_span("I could not find it"))
+
+  def test_format(self):
+    self.assertEqual(video.format_answer("moment", "75-130"), "1:15 to 2:10  (75-130 s)")
+    self.assertTrue(video.format_answer("moment", "never").startswith("No clear moment"))
+
+
+class RequestTest(unittest.TestCase):
+  def test_matches_the_measured_prompt(self):
+    with tempfile.TemporaryDirectory() as folder:
+      frame = Path(folder) / "000.jpg"
+      frame.write_bytes(b"jpg")
+      body = video.build_request([(0.5, frame)], "When?", "moment")
+    content = body["messages"][0]["content"]
+    self.assertEqual(content[0]["text"], video.PREAMBLE)
+    self.assertEqual(content[1]["text"], "Frame at 0.5 s:")
+    self.assertTrue(content[-1]["text"].startswith("When? Give the whole stretch"))
+    self.assertEqual(body["temperature"], 0)
+    self.assertFalse(body["chat_template_kwargs"]["enable_thinking"])
+
+  def test_links(self):
+    self.assertTrue(video.is_link("https://www.youtube.com/watch?v=x"))
+    self.assertFalse(video.is_link("C:/videos/https.mp4"))
+
+
+class EngineTest(unittest.TestCase):
+  def test_assets_exist_for_main_systems(self):
+    self.assertEqual(engine.asset_name("windows", "x64", "vulkan"), f"llama-{engine.LLAMA_CPP_BUILD}-bin-win-vulkan-x64.zip")
+    self.assertTrue(engine.asset_name("macos", "arm64", "metal").endswith("macos-arm64.tar.gz"))
+    with self.assertRaises(engine.EngineError):
+      engine.asset_name("macos", "arm64", "vulkan")
+
+  def test_refuses_archive_escape(self):
+    with tempfile.TemporaryDirectory() as folder:
+      archive = Path(folder) / "bad.zip"
+      with zipfile.ZipFile(archive, "w") as bundle:
+        bundle.writestr("../evil.txt", "x")
+      with self.assertRaises(engine.EngineError):
+        engine.unpack(archive, Path(folder) / "out")
+
+  def test_unpacks_tar(self):
+    with tempfile.TemporaryDirectory() as folder:
+      archive = Path(folder) / "ok.tar.gz"
+      with tarfile.open(archive, "w:gz") as bundle:
+        data = b"#!/bin/sh"
+        info = tarfile.TarInfo("build/bin/llama-server")
+        info.size = len(data)
+        bundle.addfile(info, io.BytesIO(data))
+      engine.unpack(archive, Path(folder) / "out")
+      self.assertTrue((Path(folder) / "out/build/bin/llama-server").exists())
+
+
+class ModelsTest(unittest.TestCase):
+  def test_picks_model_not_projector(self):
+    files = ["README.md", "mmproj-F16.gguf", "nock-video-4b-run1-Q4_K_M.gguf"]
+    self.assertEqual(models.pick_file(files, "*Q4_K_M.gguf", "mmproj*.gguf"), "nock-video-4b-run1-Q4_K_M.gguf")
+    self.assertEqual(models.pick_file(files, "mmproj*.gguf"), "mmproj-F16.gguf")
+    with self.assertRaises(models.ModelError):
+      models.pick_file(files + ["other-Q4_K_M.gguf"], "*Q4_K_M.gguf", "mmproj*.gguf")
+
+
+class ParserTest(unittest.TestCase):
+  def test_commands_parse(self):
+    parser = main.build_parser()
+    args = parser.parse_args(["video", "find", "clip.mp4", "the goal", "--frames", "32"])
+    self.assertEqual((args.action, args.source, args.question, args.frames), ("find", "clip.mp4", "the goal", 32))
+    self.assertEqual(parser.parse_args(["video", "summarize", "https://youtu.be/x"]).source, "https://youtu.be/x")
+
+
+if __name__ == "__main__":
+  unittest.main()

nock_cli-0.0.0/PKG-INFO

@@ -1,5 +0,0 @@
-Metadata-Version: 2.4
-Name: nock-cli
-Version: 0.0.0
-Summary: A development harness for AI agents.
-Requires-Python: >=3.9

nock_cli-0.0.0/pyproject.toml

@@ -1,9 +0,0 @@
-[project]
-name = "nock-cli"
-version = "0.0.0"
-description = "A development harness for AI agents."
-requires-python = ">=3.9"
-
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"