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

vidformer/cv2/__init__.py

@@ -19,10 +19,10 @@ except Exception:
     _opencv2 = None
 
 import re
-import uuid
 import zlib
 from bisect import bisect_right
 from fractions import Fraction
+import os
 
 import numpy as np
 
@@ -80,21 +80,36 @@ _global_cv2_server = None
 def _server():
     global _global_cv2_server
     if _global_cv2_server is None:
-        _global_cv2_server = vf.YrdenServer()
+        if "VF_IGNI_ENDPOINT" in os.environ:
+            server_endpoint = os.environ["VF_IGNI_ENDPOINT"]
+            if "VF_IGNI_API_KEY" not in os.environ:
+                raise Exception("VF_IGNI_API_KEY must be set")
+            api_key = os.environ["VF_IGNI_API_KEY"]
+            _global_cv2_server = vf.Server(server_endpoint, api_key)
+        else:
+            raise Exception(
+                "No server set for the cv2 frontend. Set VF_IGNI_ENDPOINT and VF_IGNI_API_KEY environment variables or use cv2.set_server() before use."
+            )
     return _global_cv2_server
 
 
 def set_server(server):
     """Set the server to use for the cv2 frontend."""
     global _global_cv2_server
-    assert isinstance(server, vf.YrdenServer) or isinstance(server, vf.IgniServer)
+    assert isinstance(server, vf.Server)
     _global_cv2_server = server
 
 
+def get_server():
+    """Get the server used by the cv2 frontend."""
+    return _server()
+
+
 _PIX_FMT_MAP = {
     "rgb24": "rgb24",
     "yuv420p": "rgb24",
     "yuv422p": "rgb24",
+    "yuv422p10le": "rgb24",
     "yuv444p": "rgb24",
     "yuvj420p": "rgb24",
     "yuvj422p": "rgb24",
@@ -149,28 +164,16 @@ class Frame:
 
         self._mut()
         server = _server()
-        if type(server) is vf.YrdenServer:
-            spec = vf.YrdenSpec([Fraction(0, 1)], lambda t, i: self._f, self._fmt)
-            loader = spec.load(_server())
-
-            frame_raster_rgb24 = loader[0]
-            assert type(frame_raster_rgb24) is bytes
-            assert len(frame_raster_rgb24) == self.shape[0] * self.shape[1] * 3
-            raw_data_array = np.frombuffer(frame_raster_rgb24, dtype=np.uint8)
-            frame = raw_data_array.reshape(self.shape)
+        frame = server.frame(
+            self.shape[1], self.shape[0], self._fmt["pix_fmt"], self._f
+        )
+        assert type(frame) is bytes
+        assert len(frame) == self.shape[0] * self.shape[1] * self.shape[2]
+        raw_data_array = np.frombuffer(frame, dtype=np.uint8)
+        frame = raw_data_array.reshape(self.shape)
+        if self.shape[2] == 3:
             frame = frame[:, :, ::-1]  # convert RGB to BGR
-            return frame
-        else:
-            frame = server.frame(
-                self.shape[1], self.shape[0], self._fmt["pix_fmt"], self._f
-            )
-            assert type(frame) is bytes
-            assert len(frame) == self.shape[0] * self.shape[1] * self.shape[2]
-            raw_data_array = np.frombuffer(frame, dtype=np.uint8)
-            frame = raw_data_array.reshape(self.shape)
-            if self.shape[2] == 3:
-                frame = frame[:, :, ::-1]  # convert RGB to BGR
-            return frame
+        return frame
 
     def __getitem__(self, key):
         if not isinstance(key, tuple):
@@ -316,27 +319,19 @@ class VideoCapture:
     def __init__(self, path: str):
         server = _server()
         if type(path) is str:
-            if isinstance(server, vf.YrdenServer):
+            match = re.match(r"(http|https)://([^/]+)(.*)", path)
+            if match is not None:
+                endpoint = f"{match.group(1)}://{match.group(2)}"
+                path = match.group(3)
+                if path.startswith("/"):
+                    path = path[1:]
                 self._path = path
-                self._source = vf.YrdenSource(server, str(uuid.uuid4()), path, 0)
+                self._source = server.source(path, 0, "http", {"endpoint": endpoint})
             else:
-                assert isinstance(server, vf.IgniServer)
-                match = re.match(r"(http|https)://([^/]+)(.*)", path)
-                if match is not None:
-                    endpoint = f"{match.group(1)}://{match.group(2)}"
-                    path = match.group(3)
-                    if path.startswith("/"):
-                        path = path[1:]
-                    self._path = path
-                    self._source = server.source(
-                        path, 0, "http", {"endpoint": endpoint}
-                    )
-                else:
-                    raise Exception(
-                        "Using a VideoCapture source by name only works with http(s) URLs. You need to pass an IgniSource instead."
-                    )
-        elif isinstance(path, vf.IgniSource):
-            assert isinstance(server, vf.IgniServer)
+                self._path = path
+                self._source = server.source(path, 0, "fs", {"root": "."})
+        elif isinstance(path, vf.Source):
+            assert isinstance(server, vf.Server)
             self._path = path._name
             self._source = path
         self._next_frame_idx = 0
@@ -397,26 +392,6 @@ class VideoCapture:
 
 
 class VideoWriter:
-    def __init__(self, *args, **kwargs):
-        server = _server()
-        if isinstance(server, vf.YrdenServer):
-            self._writer = _YrdenVideoWriter(*args, **kwargs)
-        elif isinstance(server, vf.IgniServer):
-            self._writer = _IgniVideoWriter(*args, **kwargs)
-        else:
-            raise Exception("Unsupported server type")
-
-    def write(self, *args, **kwargs):
-        return self._writer.write(*args, **kwargs)
-
-    def release(self, *args, **kwargs):
-        return self._writer.release(*args, **kwargs)
-
-    def spec(self, *args, **kwargs):
-        return self._writer.spec(*args, **kwargs)
-
-
-class _IgniVideoWriter:
     def __init__(
         self,
         path,
@@ -426,14 +401,13 @@ class _IgniVideoWriter:
         batch_size=1024,
         compression="gzip",
         ttl=3600,
+        pix_fmt="yuv420p",
         vod_segment_length=Fraction(2, 1),
     ):
         server = _server()
-        assert isinstance(server, vf.IgniServer)
-        if path is not None:
-            raise Exception(
-                "Igni does not support writing to a file. VideoWriter path must be None"
-            )
+        assert isinstance(server, vf.Server)
+        assert path is None or type(path) is str
+        self._path = path
         if isinstance(fps, int):
             self._f_time = Fraction(1, fps)
         elif isinstance(fps, Fraction):
@@ -446,7 +420,7 @@ class _IgniVideoWriter:
         width, height = size
         assert ttl is None or isinstance(ttl, int)
         self._spec = server.create_spec(
-            width, height, "yuv420p", vod_segment_length, 1 / self._f_time, ttl=ttl
+            width, height, pix_fmt, vod_segment_length, 1 / self._f_time, ttl=ttl
         )
         self._batch_size = batch_size
         assert compression is None or compression in ["gzip"]
@@ -498,47 +472,9 @@ class _IgniVideoWriter:
 
     def release(self):
         self._flush(True)
-
-
-class _YrdenVideoWriter:
-    def __init__(self, path, fourcc, fps, size):
-        assert isinstance(fourcc, VideoWriter_fourcc)
-        if path is not None and not isinstance(path, str):
-            raise Exception("path must be a string or None")
-        self._path = path
-        self._fourcc = fourcc
-        self._fps = fps
-        self._size = size
-
-        self._frames = []
-        self._pix_fmt = "yuv420p"
-
-    def write(self, frame):
-        frame = frameify(frame, "frame")
-
-        if frame._fmt["pix_fmt"] != self._pix_fmt:
-            f_obj = _filter_scale(frame._f, pix_fmt=self._pix_fmt)
-            self._frames.append(f_obj)
-        else:
-            self._frames.append(frame._f)
-
-    def release(self):
-        if self._path is None:
-            return
-
-        spec = self.spec()
-        server = _server()
-        spec.save(server, self._path)
-
-    def spec(self) -> vf.YrdenSpec:
-        fmt = {
-            "width": self._size[0],
-            "height": self._size[1],
-            "pix_fmt": self._pix_fmt,
-        }
-        domain = _fps_to_ts(self._fps, len(self._frames))
-        spec = vf.YrdenSpec(domain, lambda t, i: self._frames[i], fmt)
-        return spec
+        if self._path is not None:
+            server = _server()
+            server.export_spec(self._spec.id(), self._path)
 
 
 class VideoWriter_fourcc:
@@ -570,82 +506,57 @@ def imread(path, *args):
     assert path.lower().endswith((".jpg", ".jpeg", ".png"))
     server = _server()
 
-    if type(server) is vf.YrdenServer:
-        source = vf.YrdenSource(server, str(uuid.uuid4()), path, 0)
-        frame = Frame(source.iloc[0], source.fmt())
-        return frame
-    else:
-        cap = VideoCapture(path)
-        assert cap.isOpened()
-        assert len(cap._source) == 1
-        ret, frame = cap.read()
-        assert ret
-        cap.release()
-        return frame
+    cap = VideoCapture(path)
+    assert cap.isOpened()
+    assert len(cap._source) == 1
+    ret, frame = cap.read()
+    assert ret
+    cap.release()
+    return frame
 
 
 def imwrite(path, img, *args):
     if len(args) > 0:
         raise NotImplementedError("imwrite does not support additional arguments")
 
-    server = _server()
-    if type(server) is vf.IgniServer:
-        raise NotImplementedError(
-            "imwrite is only supported with YrdenServer, not IgniServer"
-        )
-
     img = frameify(img)
-
     fmt = img._fmt.copy()
     width = fmt["width"]
     height = fmt["height"]
-    f = img._f
-
-    domain = [Fraction(0, 1)]
 
     if path.lower().endswith(".png"):
-        img._mut()  # Make sure it's in rgb24
-        spec = vf.YrdenSpec(
-            domain,
-            lambda t, i: img._f,
-            {"width": width, "height": height, "pix_fmt": "rgb24"},
-        )
-        spec.save(_server(), path, encoder="png")
+        out_pix_fmt = "rgb24"
+        encoder = "png"
     elif path.lower().endswith((".jpg", ".jpeg")):
-        if img._modified:
-            # it's rgb24, we need to convert to something jpeg can handle
-            f = _filter_scale(img._f, pix_fmt="yuv420p")
-            fmt["pix_fmt"] = "yuv420p"
+        encoder = "mjpeg"
+        if img._fmt["pix_fmt"] not in ["yuvj420p", "yuvj422p", "yuvj444p"]:
+            out_pix_fmt = "yuvj420p"
         else:
-            if fmt["pix_fmt"] not in ["yuvj420p", "yuvj422p", "yuvj444p"]:
-                f = _filter_scale(img._f, pix_fmt="yuvj420p")
-                fmt["pix_fmt"] = "yuvj420p"
-
-        spec = vf.YrdenSpec(domain, lambda t, i: f, fmt)
-        spec.save(server, path, encoder="mjpeg")
+            out_pix_fmt = img._fmt["pix_fmt"]
     else:
         raise Exception("Unsupported image format")
 
+    if img._fmt["pix_fmt"] != out_pix_fmt:
+        f = _filter_scale(img._f, pix_fmt=out_pix_fmt)
+        img = Frame(f, {"width": width, "height": height, "pix_fmt": out_pix_fmt})
+
+    writer = VideoWriter(None, None, 1, (width, height), pix_fmt=out_pix_fmt)
+    writer.write(img)
+    writer.release()
+
+    spec = writer.spec()
+    server = _server()
+    server.export_spec(spec.id(), path, encoder=encoder)
+
 
-def vidplay(video, *args, **kwargs):
+def vidplay(video, method="html"):
     """
     Play a vidformer video specification.
-
-    Args:
-        video: one of [vidformer.Spec, vidformer.Source, vidformer.cv2.VideoWriter]
     """
-    if isinstance(video, vf.YrdenSpec):
-        return video.play(_server(), *args, **kwargs)
-    elif isinstance(video, vf.YrdenSource):
-        return video.play(_server(), *args, **kwargs)
-    elif isinstance(video, VideoWriter):
-        return vidplay(video._writer, *args, **kwargs)
-    elif isinstance(video, _YrdenVideoWriter):
-        return video.spec().play(_server(), *args, **kwargs)
-    elif isinstance(video, _IgniVideoWriter):
-        return video._spec.play(*args, **kwargs)
-    elif isinstance(video, vf.IgniSpec):
-        return video.play(*args, **kwargs)
+    if isinstance(video, VideoWriter):
+        return video.spec().play(method=method)
+    elif isinstance(video, vf.Spec):
+        return video.play(method=method)
     else:
         raise Exception("Unsupported video type to vidplay")
 

{vidformer-0.12.0.dist-info → vidformer-1.0.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vidformer
-Version: 0.12.0
+Version: 1.0.1
 Summary: vidformer-py is a Python 🐍 interface for [vidformer](https://github.com/ixlab/vidformer).
 Author-email: Dominik Winecki <dominikwinecki@gmail.com>
 Requires-Python: >=3.8
@@ -8,7 +8,6 @@ Description-Content-Type: text/markdown
 Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: OS Independent
 Requires-Dist: requests
-Requires-Dist: msgpack
 Requires-Dist: numpy
 Project-URL: Documentation, https://ixlab.github.io/vidformer/vidformer-py/
 Project-URL: Homepage, https://ixlab.github.io/vidformer/

vidformer-1.0.1.dist-info/RECORD

@@ -0,0 +1,6 @@
+vidformer/__init__.py,sha256=lTnRzfqleuEwb_mG4E0OZ1PgQ-8hUHiASERi_eXPiJc,29972
+vidformer/cv2/__init__.py,sha256=cgnomW6xV7Ho7cCgbuw5EfS_2JJBmAwIyt-_gmtUTyY,26829
+vidformer/supervision/__init__.py,sha256=dRHAcHiZN68gUH_2m3o7Ohsv3NBGxF4XGPeI0pn2_K4,20346
+vidformer-1.0.1.dist-info/WHEEL,sha256=_2ozNFCLWc93bK4WKHCO-eDUENDlo-dgc9cU3qokYO4,82
+vidformer-1.0.1.dist-info/METADATA,sha256=bw_C4C9EeVhsHDVywkyTwoTHPCiHJe6w3BJsWgvyAqI,1776
+vidformer-1.0.1.dist-info/RECORD,,

vidformer-0.12.0.dist-info/RECORD

@@ -1,6 +0,0 @@
-vidformer/__init__.py,sha256=2_IA8eCF8xIWqgdcpC06CSEsX_b2DPpOww3tuQlY3rg,55692
-vidformer/cv2/__init__.py,sha256=cp1qJPpxpRGCE3elmoHDxhzafZbopZ9wIkKcZJJI8HM,30105
-vidformer/supervision/__init__.py,sha256=dRHAcHiZN68gUH_2m3o7Ohsv3NBGxF4XGPeI0pn2_K4,20346
-vidformer-0.12.0.dist-info/WHEEL,sha256=_2ozNFCLWc93bK4WKHCO-eDUENDlo-dgc9cU3qokYO4,82
-vidformer-0.12.0.dist-info/METADATA,sha256=C3OsKiJjYPCgiUblJUan2-aQG5TOprdCn2cduqJBow0,1800
-vidformer-0.12.0.dist-info/RECORD,,