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

vidformer/__init__.py

@@ -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.12.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
@@ -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,534 +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.terminate()
-            try:
-                self._proc.wait(timeout=1)
-            except subprocess.TimeoutExpired:
-                self._proc.kill()
-                self._proc.wait()
-
-
-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
@@ -1364,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)
@@ -1427,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)