PyPI - vidformer - Versions diffs - 0.11.0__py3-none-any.whl → 1.0.0__py3-none-any.whl - Mend

vidformer 0.11.0py3-none-any.whl → 1.0.0py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7) hide show

vidformer/__init__.py +56 -836
vidformer/cv2/__init__.py +99 -170
vidformer/supervision/__init__.py +91 -1
{vidformer-0.11.0.dist-info → vidformer-1.0.0.dist-info}/METADATA +2 -3
vidformer-1.0.0.dist-info/RECORD +6 -0
{vidformer-0.11.0.dist-info → vidformer-1.0.0.dist-info}/WHEEL +1 -1
vidformer-0.11.0.dist-info/RECORD +0 -6

vidformer/__init__.py CHANGED Viewed

@@ -9,27 +9,17 @@ vidformer-py is a Python 🐍 interface for [vidformer](https://github.com/ixlab
 * [🧑‍💻 Source Code](https://github.com/ixlab/vidformer/tree/main/vidformer-py/)
 """
-__version__ = "0.11.0"
+__version__ = "1.0.0"
 import base64
 import gzip
 import json
-import multiprocessing
-import os
-import random
-import re
-import socket
 import struct
-import subprocess
-import threading
 import time
-import uuid
 from fractions import Fraction
 from urllib.parse import urlparse
-import msgpack
-import numpy as np
 import requests
 _in_notebook = False
@@ -105,14 +95,14 @@ def _play(namespace, hls_video_url, hls_js_url, method="html", status_url=None):
     <script src="{hls_js_url}"></script>
 </head>
 <body>
-    <div id="container"></div>
+    <div id="container-{namespace}"></div>
     <script>
         var statusUrl = '{status_url}';
         var videoSrc = '{hls_video_url}';
         var videoNamespace = '{namespace}';
         function showWaiting() {{
-            document.getElementById('container').textContent = 'Waiting...';
+            document.getElementById('container-{namespace}').textContent = 'Waiting...';
             pollStatus();
         }}
@@ -122,7 +112,7 @@ def _play(namespace, hls_video_url, hls_js_url, method="html", status_url=None):
                     .then(r => r.json())
                     .then(res => {{
                         if (res.ready) {{
-                            document.getElementById('container').textContent = '';
+                            document.getElementById('container-{namespace}').textContent = '';
                             attachHls();
                         }} else {{
                             pollStatus();
@@ -136,7 +126,7 @@ def _play(namespace, hls_video_url, hls_js_url, method="html", status_url=None):
         }}
         function attachHls() {{
-            var container = document.getElementById('container');
+            var container = document.getElementById('container-{namespace}');
             container.textContent = '';
             var video = document.createElement('video');
             video.id = 'video-' + videoNamespace;
@@ -391,7 +381,7 @@ class _FrameExpressionBlock:
         }
-class IgniSource:
+class Source:
     def __init__(self, id: str, src):
         self._name = id
         self._fmt = {
@@ -420,10 +410,10 @@ class IgniSource:
         return SourceExpr(self, idx, False)
     def __repr__(self):
-        return f"IgniSource({self._name})"
+        return f"Source({self._name})"
-class IgniSpec:
+class Spec:
     def __init__(self, id: str, src):
         self._id = id
         self._fmt = {
@@ -438,14 +428,14 @@ class IgniSpec:
     def id(self) -> str:
         return self._id
-    def play(self, *args, **kwargs):
+    def play(self, method):
         url = f"{self._vod_endpoint}playlist.m3u8"
         status_url = f"{self._vod_endpoint}status"
         hls_js_url = self._hls_js_url
-        return _play(self._id, url, hls_js_url, *args, **kwargs, status_url=status_url)
+        return _play(self._id, url, hls_js_url, method=method, status_url=status_url)
-class IgniServer:
+class Server:
     def __init__(self, endpoint: str, api_key: str):
         if not endpoint.startswith("http://") and not endpoint.startswith("https://"):
             raise Exception("Endpoint must start with http:// or https://")
@@ -457,7 +447,7 @@ class IgniServer:
         self._session = requests.Session()
         self._session.headers.update({"Authorization": f"Bearer {self._api_key}"})
         response = self._session.get(
-            f"{self._endpoint}/auth",
+            f"{self._endpoint}/v2/auth",
             headers={"Authorization": f"Bearer {self._api_key}"},
         )
         if not response.ok:
@@ -465,20 +455,20 @@ class IgniServer:
         response = response.json()
         assert response["status"] == "ok"
-    def get_source(self, id: str) -> IgniSource:
+    def get_source(self, id: str) -> Source:
         assert type(id) is str
         response = self._session.get(
-            f"{self._endpoint}/source/{id}",
+            f"{self._endpoint}/v2/source/{id}",
             headers={"Authorization": f"Bearer {self._api_key}"},
         )
         if not response.ok:
             raise Exception(response.text)
         response = response.json()
-        return IgniSource(response["id"], response)
+        return Source(response["id"], response)
     def list_sources(self) -> list[str]:
         response = self._session.get(
-            f"{self._endpoint}/source",
+            f"{self._endpoint}/v2/source",
             headers={"Authorization": f"Bearer {self._api_key}"},
         )
         if not response.ok:
@@ -489,7 +479,7 @@ class IgniServer:
     def delete_source(self, id: str):
         assert type(id) is str
         response = self._session.delete(
-            f"{self._endpoint}/source/{id}",
+            f"{self._endpoint}/v2/source/{id}",
             headers={"Authorization": f"Bearer {self._api_key}"},
         )
         if not response.ok:
@@ -514,7 +504,7 @@ class IgniServer:
             "storage_config": storage_config,
         }
         response = self._session.post(
-            f"{self._endpoint}/source/search",
+            f"{self._endpoint}/v2/source/search",
             json=req,
             headers={"Authorization": f"Bearer {self._api_key}"},
         )
@@ -525,7 +515,7 @@ class IgniServer:
     def create_source(
         self, name, stream_idx, storage_service, storage_config
-    ) -> IgniSource:
+    ) -> Source:
         assert type(name) is str
         assert type(stream_idx) is int
         assert type(storage_service) is str
@@ -540,7 +530,7 @@ class IgniServer:
             "storage_config": storage_config,
         }
         response = self._session.post(
-            f"{self._endpoint}/source",
+            f"{self._endpoint}/v2/source",
             json=req,
             headers={"Authorization": f"Bearer {self._api_key}"},
         )
@@ -551,7 +541,7 @@ class IgniServer:
         id = response["id"]
         return self.get_source(id)
-    def source(self, name, stream_idx, storage_service, storage_config) -> IgniSource:
+    def source(self, name, stream_idx, storage_service, storage_config) -> Source:
         """Convenience function for accessing sources.
         Tries to find a source with the given name, stream_idx, storage_service, and storage_config.
@@ -563,20 +553,20 @@ class IgniServer:
             return self.create_source(name, stream_idx, storage_service, storage_config)
         return self.get_source(sources[0])
-    def get_spec(self, id: str) -> IgniSpec:
+    def get_spec(self, id: str) -> Spec:
         assert type(id) is str
         response = self._session.get(
-            f"{self._endpoint}/spec/{id}",
+            f"{self._endpoint}/v2/spec/{id}",
             headers={"Authorization": f"Bearer {self._api_key}"},
         )
         if not response.ok:
             raise Exception(response.text)
         response = response.json()
-        return IgniSpec(response["id"], response)
+        return Spec(response["id"], response)
     def list_specs(self) -> list[str]:
         response = self._session.get(
-            f"{self._endpoint}/spec",
+            f"{self._endpoint}/v2/spec",
             headers={"Authorization": f"Bearer {self._api_key}"},
         )
         if not response.ok:
@@ -594,7 +584,7 @@ class IgniServer:
         ready_hook=None,
         steer_hook=None,
         ttl=None,
-    ) -> IgniSpec:
+    ) -> Spec:
         assert type(width) is int
         assert type(height) is int
         assert type(pix_fmt) is str
@@ -618,7 +608,7 @@ class IgniServer:
             "ttl": ttl,
         }
         response = self._session.post(
-            f"{self._endpoint}/spec",
+            f"{self._endpoint}/v2/spec",
             json=req,
             headers={"Authorization": f"Bearer {self._api_key}"},
         )
@@ -631,7 +621,28 @@ class IgniServer:
     def delete_spec(self, id: str):
         assert type(id) is str
         response = self._session.delete(
-            f"{self._endpoint}/spec/{id}",
+            f"{self._endpoint}/v2/spec/{id}",
+            headers={"Authorization": f"Bearer {self._api_key}"},
+        )
+        if not response.ok:
+            raise Exception(response.text)
+        response = response.json()
+        assert response["status"] == "ok"
+    def export_spec(
+        self, id: str, path: str, encoder=None, encoder_opts=None, format=None
+    ):
+        assert type(id) is str
+        assert type(path) is str
+        req = {
+            "path": path,
+            "encoder": encoder,
+            "encoder_opts": encoder_opts,
+            "format": format,
+        }
+        response = self._session.post(
+            f"{self._endpoint}/v2/spec/{id}/export",
+            json=req,
             headers={"Authorization": f"Bearer {self._api_key}"},
         )
         if not response.ok:
@@ -640,7 +651,7 @@ class IgniServer:
         assert response["status"] == "ok"
     def push_spec_part(self, spec_id, pos, frames, terminal):
-        if type(spec_id) is IgniSpec:
+        if type(spec_id) is Spec:
             spec_id = spec_id._id
         assert type(spec_id) is str
         assert type(pos) is int
@@ -668,7 +679,7 @@ class IgniServer:
             "terminal": terminal,
         }
         response = self._session.post(
-            f"{self._endpoint}/spec/{spec_id}/part",
+            f"{self._endpoint}/v2/spec/{spec_id}/part",
             json=req,
             headers={"Authorization": f"Bearer {self._api_key}"},
         )
@@ -680,7 +691,7 @@ class IgniServer:
     def push_spec_part_block(
         self, spec_id: str, pos, blocks, terminal, compression="gzip"
     ):
-        if type(spec_id) is IgniSpec:
+        if type(spec_id) is Spec:
             spec_id = spec_id._id
         assert type(spec_id) is str
         assert type(pos) is int
@@ -711,7 +722,7 @@ class IgniServer:
             "blocks": req_blocks,
         }
         response = self._session.post(
-            f"{self._endpoint}/spec/{spec_id}/part_block",
+            f"{self._endpoint}/v2/spec/{spec_id}/part_block",
             json=req,
             headers={"Authorization": f"Bearer {self._api_key}"},
         )
@@ -743,7 +754,7 @@ class IgniServer:
             },
         }
         response = self._session.post(
-            f"{self._endpoint}/frame",
+            f"{self._endpoint}/v2/frame",
             json=req,
             headers={"Authorization": f"Bearer {self._api_key}"},
         )
@@ -756,529 +767,6 @@ class IgniServer:
         return response_body
-class YrdenSpec:
-    """
-    A video transformation specification.
-    See https://ixlab.github.io/vidformer/concepts.html for more information.
-    """
-    def __init__(self, domain: list[Fraction], render, fmt: dict):
-        self._domain = domain
-        self._render = render
-        self._fmt = fmt
-    def __repr__(self):
-        if len(self._domain) <= 20:
-            lines = []
-            for i, t in enumerate(self._domain):
-                frame_expr = self._render(t, i)
-                lines.append(
-                    f"{t.numerator}/{t.denominator} => {frame_expr}",
-                )
-            return "\n".join(lines)
-        else:
-            lines = []
-            for i, t in enumerate(self._domain[:10]):
-                frame_expr = self._render(t, i)
-                lines.append(
-                    f"{t.numerator}/{t.denominator} => {frame_expr}",
-                )
-            lines.append("...")
-            for i, t in enumerate(self._domain[-10:]):
-                frame_expr = self._render(t, i)
-                lines.append(
-                    f"{t.numerator}/{t.denominator} => {frame_expr}",
-                )
-            return "\n".join(lines)
-    def _sources(self):
-        s = set()
-        for i, t in enumerate(self._domain):
-            frame_expr = self._render(t, i)
-            s = s.union(frame_expr._sources())
-        return s
-    def _to_json_spec(self):
-        frames = []
-        s = set()
-        f = {}
-        for i, t in enumerate(self._domain):
-            frame_expr = self._render(t, i)
-            s = s.union(frame_expr._sources())
-            f = {**f, **frame_expr._filters()}
-            frame = [[t.numerator, t.denominator], frame_expr._to_json_spec()]
-            frames.append(frame)
-        return {"frames": frames}, s, f
-    def play(self, server, method="html", verbose=False):
-        """Play the video live in the notebook."""
-        spec, sources, filters = self._to_json_spec()
-        spec_json_bytes = json.dumps(spec).encode("utf-8")
-        spec_obj_json_gzip = gzip.compress(spec_json_bytes, compresslevel=1)
-        spec_obj_json_gzip_b64 = base64.b64encode(spec_obj_json_gzip).decode("utf-8")
-        sources = [
-            {
-                "name": s._name,
-                "path": s._path,
-                "stream": s._stream,
-                "service": s._service.as_json() if s._service is not None else None,
-            }
-            for s in sources
-        ]
-        filters = {
-            k: {
-                "filter": v._func,
-                "args": v._kwargs,
-            }
-            for k, v in filters.items()
-        }
-        if verbose:
-            print(f"Sending to server. Spec is {len(spec_obj_json_gzip_b64)} bytes")
-        resp = server._new(spec_obj_json_gzip_b64, sources, filters, self._fmt)
-        hls_video_url = resp["stream_url"]
-        hls_player_url = resp["player_url"]
-        namespace = resp["namespace"]
-        hls_js_url = server.hls_js_url()
-        if method == "link":
-            return hls_video_url
-        if method == "player":
-            return hls_player_url
-        if method == "iframe":
-            from IPython.display import IFrame
-            return IFrame(hls_player_url, width=1280, height=720)
-        if method == "html":
-            from IPython.display import HTML
-            # We add a namespace to the video element to avoid conflicts with other videos
-            html_code = f"""
-<!DOCTYPE html>
-<html>
-<head>
-    <title>HLS Video Player</title>
-    <!-- Include hls.js library -->
-    <script src="{hls_js_url}"></script>
-</head>
-<body>
-    <!-- Video element -->
-    <video id="video-{namespace}" controls width="640" height="360" autoplay></video>
-    <script>
-        var video = document.getElementById('video-{namespace}');
-        var videoSrc = '{hls_video_url}';
-        var hls = new Hls();
-        hls.loadSource(videoSrc);
-        hls.attachMedia(video);
-        hls.on(Hls.Events.MANIFEST_PARSED, function() {{
-            video.play();
-        }});
-    </script>
-</body>
-</html>
-"""
-            return HTML(data=html_code)
-        else:
-            return hls_player_url
-    def load(self, server):
-        spec, sources, filters = self._to_json_spec()
-        spec_json_bytes = json.dumps(spec).encode("utf-8")
-        spec_obj_json_gzip = gzip.compress(spec_json_bytes, compresslevel=1)
-        spec_obj_json_gzip_b64 = base64.b64encode(spec_obj_json_gzip).decode("utf-8")
-        sources = [
-            {
-                "name": s._name,
-                "path": s._path,
-                "stream": s._stream,
-                "service": s._service.as_json() if s._service is not None else None,
-            }
-            for s in sources
-        ]
-        filters = {
-            k: {
-                "filter": v._func,
-                "args": v._kwargs,
-            }
-            for k, v in filters.items()
-        }
-        resp = server._new(spec_obj_json_gzip_b64, sources, filters, self._fmt)
-        namespace = resp["namespace"]
-        return YrdenLoader(server, namespace, self._domain)
-    def save(self, server, pth, encoder=None, encoder_opts=None, format=None):
-        """Save the video to a file."""
-        assert encoder is None or type(encoder) is str
-        assert encoder_opts is None or type(encoder_opts) is dict
-        if encoder_opts is not None:
-            for k, v in encoder_opts.items():
-                assert type(k) is str and type(v) is str
-        spec, sources, filters = self._to_json_spec()
-        spec_json_bytes = json.dumps(spec).encode("utf-8")
-        spec_obj_json_gzip = gzip.compress(spec_json_bytes, compresslevel=1)
-        spec_obj_json_gzip_b64 = base64.b64encode(spec_obj_json_gzip).decode("utf-8")
-        sources = [
-            {
-                "name": s._name,
-                "path": s._path,
-                "stream": s._stream,
-                "service": s._service.as_json() if s._service is not None else None,
-            }
-            for s in sources
-        ]
-        filters = {
-            k: {
-                "filter": v._func,
-                "args": v._kwargs,
-            }
-            for k, v in filters.items()
-        }
-        resp = server._export(
-            pth,
-            spec_obj_json_gzip_b64,
-            sources,
-            filters,
-            self._fmt,
-            encoder,
-            encoder_opts,
-            format,
-        )
-        return resp
-    def _vrod_bench(self, server):
-        out = {}
-        pth = "spec.json"
-        start_t = time.time()
-        with open(pth, "w") as outfile:
-            spec, sources, filters = self._to_json_spec()
-            outfile.write(json.dumps(spec))
-        sources = [
-            {
-                "name": s._name,
-                "path": s._path,
-                "stream": s._stream,
-                "service": s._service.as_json() if s._service is not None else None,
-            }
-            for s in sources
-        ]
-        filters = {
-            k: {
-                "filter": v._func,
-                "args": v._kwargs,
-            }
-            for k, v in filters.items()
-        }
-        end_t = time.time()
-        out["vrod_create_spec"] = end_t - start_t
-        start = time.time()
-        resp = server._new(pth, sources, filters, self._fmt)
-        end = time.time()
-        out["vrod_register"] = end - start
-        stream_url = resp["stream_url"]
-        first_segment = stream_url.replace("stream.m3u8", "segment-0.ts")
-        start = time.time()
-        r = requests.get(first_segment)
-        r.raise_for_status()
-        end = time.time()
-        out["vrod_first_segment"] = end - start
-        return out
-    def _dve2_bench(self, server):
-        pth = "spec.json"
-        out = {}
-        start_t = time.time()
-        with open(pth, "w") as outfile:
-            spec, sources, filters = self._to_json_spec()
-            outfile.write(json.dumps(spec))
-        sources = [
-            {
-                "name": s._name,
-                "path": s._path,
-                "stream": s._stream,
-                "service": s._service.as_json() if s._service is not None else None,
-            }
-            for s in sources
-        ]
-        filters = {
-            k: {
-                "filter": v._func,
-                "args": v._kwargs,
-            }
-            for k, v in filters.items()
-        }
-        end_t = time.time()
-        out["dve2_create_spec"] = end_t - start_t
-        start = time.time()
-        resp = server._export(pth, sources, filters, self._fmt, None, None)
-        resp.raise_for_status()
-        end = time.time()
-        out["dve2_exec"] = end - start
-        return out
-class YrdenLoader:
-    def __init__(self, server, namespace: str, domain):
-        self._server = server
-        self._namespace = namespace
-        self._domain = domain
-    def _chunk(self, start_i, end_i):
-        return self._server._raw(self._namespace, start_i, end_i)
-    def __len__(self):
-        return len(self._domain)
-    def _find_index_by_rational(self, value):
-        if value not in self._domain:
-            raise ValueError(f"Rational timestamp {value} is not in the domain")
-        return self._domain.index(value)
-    def __getitem__(self, index):
-        if isinstance(index, slice):
-            start = index.start if index.start is not None else 0
-            end = index.stop if index.stop is not None else len(self._domain)
-            assert start >= 0 and start < len(self._domain)
-            assert end >= 0 and end <= len(self._domain)
-            assert start <= end
-            num_frames = end - start
-            all_bytes = self._chunk(start, end - 1)
-            all_bytes_len = len(all_bytes)
-            assert all_bytes_len % num_frames == 0
-            return [
-                all_bytes[
-                    i
-                    * all_bytes_len
-                    // num_frames : (i + 1)
-                    * all_bytes_len
-                    // num_frames
-                ]
-                for i in range(num_frames)
-            ]
-        elif isinstance(index, int):
-            assert index >= 0 and index < len(self._domain)
-            return self._chunk(index, index)
-        else:
-            raise TypeError(
-                "Invalid argument type for iloc. Use a slice or an integer."
-            )
-class YrdenServer:
-    """
-    A connection to a Yrden server.
-    A yrden server is the main API for local use of vidformer.
-    """
-    def __init__(self, domain=None, port=None, bin=None, hls_prefix=None):
-        """
-        Connect to a Yrden server
-        Can either connect to an existing server, if domain and port are provided, or start a new server using the provided binary.
-        If no domain or binary is provided, the `VIDFORMER_BIN` environment variable is used.
-        """
-        self._domain = domain
-        self._port = port
-        self._proc = None
-        if self._port is None:
-            if bin is None:
-                if os.getenv("VIDFORMER_BIN") is not None:
-                    bin = os.getenv("VIDFORMER_BIN")
-                else:
-                    bin = "vidformer-cli"
-            self._domain = "localhost"
-            self._port = random.randint(49152, 65535)
-            cmd = [bin, "yrden", "--port", str(self._port)]
-            if _in_notebook:
-                # We need to print the URL in the notebook
-                # This is a trick to get VS Code to forward the port
-                cmd += ["--print-url"]
-            if hls_prefix is not None:
-                if type(hls_prefix) is not str:
-                    raise Exception("hls_prefix must be a string")
-                cmd += ["--hls-prefix", hls_prefix]
-            self._proc = subprocess.Popen(cmd)
-        version = _wait_for_url(f"http://{self._domain}:{self._port}/")
-        if version is None:
-            raise Exception("Failed to connect to server")
-        expected_version = f"vidformer-yrden v{__version__}"
-        if version != expected_version:
-            print(
-                f"Warning: Expected version `{expected_version}`, got `{version}`. API may not be compatible!"
-            )
-    def _source(self, name: str, path: str, stream: int, service):
-        r = requests.post(
-            f"http://{self._domain}:{self._port}/source",
-            json={
-                "name": name,
-                "path": path,
-                "stream": stream,
-                "service": service.as_json() if service is not None else None,
-            },
-        )
-        if not r.ok:
-            raise Exception(r.text)
-        resp = r.json()
-        resp["ts"] = [Fraction(x[0], x[1]) for x in resp["ts"]]
-        return resp
-    def _new(self, spec, sources, filters, fmt):
-        req = {
-            "spec": spec,
-            "sources": sources,
-            "filters": filters,
-            "width": fmt["width"],
-            "height": fmt["height"],
-            "pix_fmt": fmt["pix_fmt"],
-        }
-        r = requests.post(f"http://{self._domain}:{self._port}/new", json=req)
-        if not r.ok:
-            raise Exception(r.text)
-        return r.json()
-    def _export(self, pth, spec, sources, filters, fmt, encoder, encoder_opts, format):
-        req = {
-            "spec": spec,
-            "sources": sources,
-            "filters": filters,
-            "width": fmt["width"],
-            "height": fmt["height"],
-            "pix_fmt": fmt["pix_fmt"],
-            "output_path": pth,
-            "encoder": encoder,
-            "encoder_opts": encoder_opts,
-            "format": format,
-        }
-        r = requests.post(f"http://{self._domain}:{self._port}/export", json=req)
-        if not r.ok:
-            raise Exception(r.text)
-        return r.json()
-    def _raw(self, namespace, start_i, end_i):
-        r = requests.get(
-            f"http://{self._domain}:{self._port}/{namespace}/raw/{start_i}-{end_i}"
-        )
-        if not r.ok:
-            raise Exception(r.text)
-        return r.content
-    def hls_js_url(self):
-        """Return the link to the yrden-hosted hls.js file"""
-        return f"http://{self._domain}:{self._port}/hls.js"
-    def __del__(self):
-        if self._proc is not None:
-            self._proc.kill()
-class YrdenSource:
-    """A video source."""
-    def __init__(
-        self, server: YrdenServer, name: str, path: str, stream: int, service=None
-    ):
-        if service is None:
-            # check if path is a http URL and, if so, automatically set the service
-            # for example, the following code should work with just vf.Source(server, "tos_720p", "https://f.dominik.win/data/dve2/tos_720p.mp4")
-            # this creates a storage service with endpoint "https://f.dominik.win/" and path "data/dve2/tos_720p.mp4"
-            # don't use the root parameter in this case
-            match = re.match(r"(http|https)://([^/]+)(.*)", path)
-            if match is not None:
-                endpoint = f"{match.group(1)}://{match.group(2)}"
-                path = match.group(3)
-                # remove leading slash
-                if path.startswith("/"):
-                    path = path[1:]
-                service = YrdenStorageService("http", endpoint=endpoint)
-        self._server = server
-        self._name = name
-        self._path = path
-        self._stream = stream
-        self._service = service
-        self.iloc = _SourceILoc(self)
-        self._src = self._server._source(
-            self._name, self._path, self._stream, self._service
-        )
-    def fmt(self):
-        return {
-            "width": self._src["width"],
-            "height": self._src["height"],
-            "pix_fmt": self._src["pix_fmt"],
-        }
-    def ts(self):
-        return self._src["ts"]
-    def __len__(self):
-        return len(self._src["ts"])
-    def __getitem__(self, idx):
-        if type(idx) is not Fraction:
-            raise Exception("Source index must be a Fraction")
-        return SourceExpr(self, idx, False)
-    def play(self, *args, **kwargs):
-        """Play the video live in the notebook."""
-        domain = self.ts()
-        def render(t, _i):
-            return self[t]
-        spec = YrdenSpec(domain, render, self.fmt())
-        return spec.play(*args, **kwargs)
-class YrdenStorageService:
-    def __init__(self, service: str, **kwargs):
-        if type(service) is not str:
-            raise Exception("Service name must be a string")
-        self._service = service
-        for k, v in kwargs.items():
-            if type(v) is not str:
-                raise Exception(f"Value of {k} must be a string")
-        self._config = kwargs
-    def as_json(self):
-        return {"service": self._service, "config": self._config}
-    def __repr__(self):
-        return f"{self._service}(config={self._config})"
 class SourceExpr:
     def __init__(self, source, idx, is_iloc):
         self._source = source
@@ -1359,20 +847,8 @@ def _json_arg(arg, skip_data_anot=False):
 class Filter:
     """A video filter."""
-    def __init__(self, name: str, tl_func=None, **kwargs):
-        self._name = name
-        # tl_func is the top level func, which is the true implementation, not just a pretty name
-        if tl_func is None:
-            self._func = name
-        else:
-            self._func = tl_func
-        # filter infra args, not invocation args
-        for k, v in kwargs.items():
-            if type(v) is not str:
-                raise Exception(f"Value of {k} must be a string")
-        self._kwargs = kwargs
+    def __init__(self, func: str):
+        self._func = func
     def __call__(self, *args, **kwargs):
         return FilterExpr(self, args, kwargs)
@@ -1422,259 +898,3 @@ class FilterExpr:
             if type(arg) is FilterExpr:
                 f = {**f, **arg._filters()}
         return f
-class UDF:
-    """User-defined filter superclass"""
-    def __init__(self, name: str):
-        self._name = name
-        self._socket_path = None
-        self._p = None
-    def filter(self, *args, **kwargs):
-        raise Exception("User must implement the filter method")
-    def filter_type(self, *args, **kwargs):
-        raise Exception("User must implement the filter_type method")
-    def into_filter(self):
-        assert self._socket_path is None
-        self._socket_path = f"/tmp/vidformer-{self._name}-{str(uuid.uuid4())}.sock"
-        self._p = multiprocessing.Process(
-            target=_run_udf_host, args=(self, self._socket_path)
-        )
-        self._p.start()
-        return Filter(
-            name=self._name, tl_func="IPC", socket=self._socket_path, func=self._name
-        )
-    def _handle_connection(self, connection):
-        try:
-            while True:
-                frame_len = connection.recv(4)
-                if not frame_len or len(frame_len) != 4:
-                    break
-                frame_len = int.from_bytes(frame_len, byteorder="big")
-                data = connection.recv(frame_len)
-                if not data:
-                    break
-                while len(data) < frame_len:
-                    new_data = connection.recv(frame_len - len(data))
-                    if not new_data:
-                        raise Exception("Partial data received")
-                    data += new_data
-                obj = msgpack.unpackb(data, raw=False)
-                f_op, f_args, f_kwargs = (
-                    obj["op"],
-                    obj["args"],
-                    obj["kwargs"],
-                )
-                response = None
-                if f_op == "filter":
-                    f_args = [self._deser_filter(x) for x in f_args]
-                    f_kwargs = {k: self._deser_filter(v) for k, v in f_kwargs}
-                    response = self.filter(*f_args, **f_kwargs)
-                    if type(response) is not UDFFrame:
-                        raise Exception(
-                            f"filter must return a UDFFrame, got {type(response)}"
-                        )
-                    if response.frame_type().pix_fmt() != "rgb24":
-                        raise Exception(
-                            f"filter must return a frame with pix_fmt 'rgb24', got {response.frame_type().pix_fmt()}"
-                        )
-                    response = response._response_ser()
-                elif f_op == "filter_type":
-                    f_args = [self._deser_filter_type(x) for x in f_args]
-                    f_kwargs = {k: self._deser_filter_type(v) for k, v in f_kwargs}
-                    response = self.filter_type(*f_args, **f_kwargs)
-                    if type(response) is not UDFFrameType:
-                        raise Exception(
-                            f"filter_type must return a UDFFrameType, got {type(response)}"
-                        )
-                    if response.pix_fmt() != "rgb24":
-                        raise Exception(
-                            f"filter_type must return a frame with pix_fmt 'rgb24', got {response.pix_fmt()}"
-                        )
-                    response = response._response_ser()
-                else:
-                    raise Exception(f"Unknown operation: {f_op}")
-                response = msgpack.packb(response, use_bin_type=True)
-                response_len = len(response).to_bytes(4, byteorder="big")
-                connection.sendall(response_len)
-                connection.sendall(response)
-        finally:
-            connection.close()
-    def _deser_filter_type(self, obj):
-        assert type(obj) is dict
-        keys = list(obj.keys())
-        assert len(keys) == 1
-        type_key = keys[0]
-        assert type_key in ["FrameType", "String", "Int", "Bool"]
-        if type_key == "FrameType":
-            frame = obj[type_key]
-            assert type(frame) is dict
-            assert "width" in frame
-            assert "height" in frame
-            assert "format" in frame
-            assert type(frame["width"]) is int
-            assert type(frame["height"]) is int
-            assert frame["format"] == 2  # AV_PIX_FMT_RGB24
-            return UDFFrameType(frame["width"], frame["height"], "rgb24")
-        elif type_key == "String":
-            assert type(obj[type_key]) is str
-            return obj[type_key]
-        elif type_key == "Int":
-            assert type(obj[type_key]) is int
-            return obj[type_key]
-        elif type_key == "Bool":
-            assert type(obj[type_key]) is bool
-            return obj[type_key]
-        else:
-            assert False, f"Unknown type: {type_key}"
-    def _deser_filter(self, obj):
-        assert type(obj) is dict
-        keys = list(obj.keys())
-        assert len(keys) == 1
-        type_key = keys[0]
-        assert type_key in ["Frame", "String", "Int", "Bool"]
-        if type_key == "Frame":
-            frame = obj[type_key]
-            assert type(frame) is dict
-            assert "data" in frame
-            assert "width" in frame
-            assert "height" in frame
-            assert "format" in frame
-            assert type(frame["width"]) is int
-            assert type(frame["height"]) is int
-            assert frame["format"] == "rgb24"
-            assert type(frame["data"]) is bytes
-            data = np.frombuffer(frame["data"], dtype=np.uint8)
-            data = data.reshape(frame["height"], frame["width"], 3)
-            return UDFFrame(
-                data, UDFFrameType(frame["width"], frame["height"], "rgb24")
-            )
-        elif type_key == "String":
-            assert type(obj[type_key]) is str
-            return obj[type_key]
-        elif type_key == "Int":
-            assert type(obj[type_key]) is int
-            return obj[type_key]
-        elif type_key == "Bool":
-            assert type(obj[type_key]) is bool
-            return obj[type_key]
-        else:
-            assert False, f"Unknown type: {type_key}"
-    def _host(self, socket_path: str):
-        if os.path.exists(socket_path):
-            os.remove(socket_path)
-        # start listening on the socket
-        sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
-        sock.bind(socket_path)
-        sock.listen(1)
-        while True:
-            # accept incoming connection
-            connection, client_address = sock.accept()
-            thread = threading.Thread(
-                target=self._handle_connection, args=(connection,)
-            )
-            thread.start()
-    def __del__(self):
-        if self._socket_path is not None:
-            self._p.terminate()
-            if os.path.exists(self._socket_path):
-                # it's possible the process hasn't even created the socket yet
-                os.remove(self._socket_path)
-class UDFFrameType:
-    """
-    Frame type for use in UDFs.
-    """
-    def __init__(self, width: int, height: int, pix_fmt: str):
-        assert type(width) is int
-        assert type(height) is int
-        assert type(pix_fmt) is str
-        self._width = width
-        self._height = height
-        self._pix_fmt = pix_fmt
-    def width(self):
-        return self._width
-    def height(self):
-        return self._height
-    def pix_fmt(self):
-        return self._pix_fmt
-    def _response_ser(self):
-        return {
-            "frame_type": {
-                "width": self._width,
-                "height": self._height,
-                "format": 2,  # AV_PIX_FMT_RGB24
-            }
-        }
-    def __repr__(self):
-        return f"FrameType<{self._width}x{self._height}, {self._pix_fmt}>"
-class UDFFrame:
-    """A symbolic reference to a frame for use in UDFs."""
-    def __init__(self, data: np.ndarray, f_type: UDFFrameType):
-        assert type(data) is np.ndarray
-        assert type(f_type) is UDFFrameType
-        # We only support RGB24 for now
-        assert data.dtype == np.uint8
-        assert data.shape[2] == 3
-        # check type matches
-        assert data.shape[0] == f_type.height()
-        assert data.shape[1] == f_type.width()
-        assert f_type.pix_fmt() == "rgb24"
-        self._data = data
-        self._f_type = f_type
-    def data(self):
-        return self._data
-    def frame_type(self):
-        return self._f_type
-    def _response_ser(self):
-        return {
-            "frame": {
-                "data": self._data.tobytes(),
-                "width": self._f_type.width(),
-                "height": self._f_type.height(),
-                "format": "rgb24",
-            }
-        }
-    def __repr__(self):
-        return f"Frame<{self._f_type.width()}x{self._f_type.height()}, {self._f_type.pix_fmt()}>"
-def _run_udf_host(udf: UDF, socket_path: str):
-    udf._host(socket_path)

vidformer 0.11.0__py3-none-any.whl → 1.0.0__py3-none-any.whl

vidformer 0.11.0py3-none-any.whl → 1.0.0py3-none-any.whl