flowtracks 1.7.1.dev1__tar.gz → 1.8.1.dev1__tar.gz

{flowtracks-1.7.1.dev1 → flowtracks-1.8.1.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flowtracks
-Version: 1.7.1.dev1
+Version: 1.8.1.dev1
 Summary: Library for handling 3D PTV trajectory databases and Lagrangian/Eulerian turbulence post-processing.
 Author-email: Yosef Meller <yosefm@gmail.com>
 License-Expression: GPL-3.0-only AND BSD-3-Clause

flowtracks-1.8.1.dev1/examples/compare_smoothing.py

@@ -0,0 +1,123 @@
+"""Synthetic comparison of Savitzky-Golay vs. scipy smoothing-spline smoothing.
+
+Generates a known smooth 3D trajectory, adds position noise, introduces
+frame gaps, and (optionally) splits/relinks the track. Runs both
+``flowtracks.smoothing.savitzky_golay`` and ``smoothing_spline`` and reports
+RMSE of position / velocity / acceleration against the noise-free ground
+truth at the observed frames.
+
+Run with:  uv run python examples/compare_smoothing.py
+"""
+
+import numpy as np
+
+from flowtracks import smoothing
+from flowtracks.trajectory import Trajectory
+
+
+def ground_truth(t):
+    pos = np.column_stack(
+        [
+            0.05 * t + 0.3 * np.sin(0.4 * t),
+            0.2 * np.cos(0.3 * t),
+            0.1 * t + 0.05 * np.sin(0.7 * t),
+        ]
+    )
+    vel = np.column_stack(
+        [
+            0.05 + 0.3 * 0.4 * np.cos(0.4 * t),
+            -0.2 * 0.3 * np.sin(0.3 * t),
+            0.1 + 0.05 * 0.7 * np.cos(0.7 * t),
+        ]
+    )
+    acc = np.column_stack(
+        [
+            -0.3 * 0.4 * 0.4 * np.sin(0.4 * t),
+            -0.2 * 0.3 * 0.3 * np.cos(0.3 * t),
+            -0.05 * 0.7 * 0.7 * np.sin(0.7 * t),
+        ]
+    )
+    return pos, vel, acc
+
+
+def make_noisy_track(n=120, fps=30.0, noise=0.02, gap_frames=(), seed=0):
+    rng = np.random.default_rng(seed)
+    t_full = np.arange(n, dtype=float)
+    pos0, _, _ = ground_truth(t_full)
+    keep = np.setdiff1d(t_full, np.asarray(gap_frames, dtype=float))
+    t = keep.astype(float)
+    pos = pos0[keep.astype(int)] + rng.normal(0, noise, (len(t), 3))
+    return t, pos, t_full, pos0
+
+
+def rmse(a, b):
+    return float(np.sqrt(np.mean((a - b) ** 2)))
+
+
+def run_case(label, t, pos, t_full, pos0, fps):
+    tr = Trajectory(pos, np.zeros_like(pos), t, 0)
+    gt_pos = pos0[t.astype(int)]
+    gt_vel = ground_truth(t)[1]
+    gt_acc = ground_truth(t)[2]
+
+    # Savitzky-Golay (needs uniform-ish; use window 11)
+    try:
+        sg = smoothing.savitzky_golay(
+            [tr], fps=fps, window_size=11, order=3, min_window=7
+        )
+        sg = sg[0] if sg else None
+    except Exception as e:
+        sg = None
+        print("  SG failed:", e)
+
+    sp = smoothing.smoothing_spline([tr], fps=fps)
+    sp = sp[0] if sp else None
+
+    print(f"\n=== {label}  (n={len(t)}, fps={fps}) ===")
+    print(f"{'method':<16}{'pos RMSE':>12}{'vel RMSE':>12}{'acc RMSE':>12}")
+    for name, sm in (
+        ("noisy input", None),
+        ("Savitzky-Golay", sg),
+        ("smoothing spline", sp),
+    ):
+        if sm is None and name != "noisy input":
+            print(f"{name:<16}{'n/a':>12}{'n/a':>12}{'n/a':>12}")
+            continue
+        if name == "noisy input":
+            p_rmse = rmse(pos, gt_pos)
+            print(f"{name:<16}{p_rmse:>12.4e}{'-':>12}{'-':>12}")
+            continue
+        p = rmse(sm.pos(), gt_pos)
+        v = rmse(sm.velocity(), gt_vel)
+        a = rmse(sm.accel(), gt_acc)
+        print(f"{name:<16}{p:>12.4e}{v:>12.4e}{a:>12.4e}")
+
+
+def main():
+    fps = 30.0
+
+    # 1. Clean-ish, uniform, no gaps
+    t, pos, tf, p0 = make_noisy_track(n=120, fps=fps, noise=0.02, seed=1)
+    run_case("uniform, no gaps", t, pos, tf, p0, fps)
+
+    # 2. With frame gaps
+    t, pos, tf, p0 = make_noisy_track(
+        n=120, fps=fps, noise=0.02, gap_frames=[20, 35, 36, 80], seed=2
+    )
+    run_case("with gaps", t, pos, tf, p0, fps)
+
+    # 3. Relinked: split into two segments then concatenate time (gap in middle)
+    t, pos, tf, p0 = make_noisy_track(n=120, fps=fps, noise=0.02, seed=3)
+    # simulate a break: remove a chunk, then "relink" by just keeping rest
+    mask = (t < 40) | (t > 55)
+    t_r = t[mask]
+    pos_r = pos[mask]
+    run_case("relinked (missing middle)", t_r, pos_r, tf, p0, fps)
+
+    # 4. High noise
+    t, pos, tf, p0 = make_noisy_track(n=200, fps=fps, noise=0.1, seed=4)
+    run_case("high noise, n=200", t, pos, tf, p0, fps)
+
+
+if __name__ == "__main__":
+    main()

{flowtracks-1.7.1.dev1 → flowtracks-1.8.1.dev1}/flowtracks/__init__.py

@@ -27,7 +27,7 @@ from flowtracks.phasing import (
     phase_of_frame,
     validate_bins,
 )
-from flowtracks.smoothing import savitzky_golay
+from flowtracks.smoothing import savitzky_golay, smoothing_spline
 from flowtracks.stitching import stitch_trajectories
 from flowtracks.writers import (
     export_run_to_paraview,
@@ -39,6 +39,7 @@ from flowtracks.writers import (
 __all__ = [
     "stitch_trajectories",
     "savitzky_golay",
+    "smoothing_spline",
     "eulerian_grid",
     "eulerian_windowed",
     "clean_field",

{flowtracks-1.7.1.dev1 → flowtracks-1.8.1.dev1}/flowtracks/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.7.1.dev1'
-__version_tuple__ = version_tuple = (1, 7, 1, 'dev1')
+__version__ = version = '1.8.1.dev1'
+__version_tuple__ = version_tuple = (1, 8, 1, 'dev1')
 
-__commit_id__ = commit_id = 'g0d6559e13'
+__commit_id__ = commit_id = 'gc4c1d8183'

{flowtracks-1.7.1.dev1 → flowtracks-1.8.1.dev1}/flowtracks/clean.py

@@ -27,32 +27,34 @@ value came from.
 import numpy as np
 
 from flowtracks.repair import repair_arrays
-from flowtracks.smoothing import savitzky_golay
+from flowtracks.smoothing import savitzky_golay, smoothing_spline
 from flowtracks.stitching import stitch_trajectories
 from flowtracks.trajectory import Trajectory
 
 #: Default settings of :func:`clean_trajectories` (positions in metres).
 CLEAN_DEFAULTS = dict(
-    fps=None,                  # frame rate [Hz]; required
-    repair_max_gap=1,          # repair: max frame gap for attach / join,
+    fps=None,  # frame rate [Hz]; required
+    repair_max_gap=1,  # repair: max frame gap for attach / join,
     repair_max_distance_mm=0.3,  # max distance [mm],
     repair_link_percentile=99.9,  # link check calibrated on this percentile,
-    repair_cut_factor=2.0,     # cut threshold factor,
-    repair_cut=True,           # and which of the three repairs run
+    repair_cut_factor=2.0,  # cut threshold factor,
+    repair_cut=True,  # and which of the three repairs run
     repair_attach=True,
     repair_join=True,
-    sg_window=7,               # Savitzky-Golay window / order
+    sg_window=7,  # Savitzky-Golay window / order
     sg_order=2,
-    kink_deg=90.0,             # kink split: turn angle ...
-    kink_step_mm=25.0,         # ... on steps longer than this
-    gap1=12,                   # first stitch: max gap [frames],
-    dist1=0.05,                #   max distance [m],
-    vd1=0.5,                   #   max velocity difference [m/s]
-    gap2=8,                    # second (tight) stitch on clean ends
+    smooth_method="spline",  # "spline" (default) or "savitzky_golay"
+    spline_lam=None,  # smoothing-spline lam (None -> GCV)
+    kink_deg=90.0,  # kink split: turn angle ...
+    kink_step_mm=25.0,  # ... on steps longer than this
+    gap1=12,  # first stitch: max gap [frames],
+    dist1=0.05,  #   max distance [m],
+    vd1=0.5,  #   max velocity difference [m/s]
+    gap2=8,  # second (tight) stitch on clean ends
     dist2=0.025,
     vd2=0.35,
-    win_long=0,                # >0: final smoothing (win_long, order_long)
-    order_long=3,              #   for tracks with >= len_long points
+    win_long=0,  # >0: final smoothing (win_long, order_long)
+    order_long=3,  #   for tracks with >= len_long points
     len_long=25,
 )
 
@@ -107,8 +109,11 @@ def trajectories_from_arrays(trajid, time, pos):
         e = int(bounds[i]) if i < len(bounds) else len(tj)
         if e - s >= 2:
             o = np.argsort(tm[s:e], kind="stable")
-            out.append(Trajectory(pp[s:e][o], np.zeros_like(pp[s:e][o]),
-                                  tm[s:e][o], int(tj[s])))
+            out.append(
+                Trajectory(
+                    pp[s:e][o], np.zeros_like(pp[s:e][o]), tm[s:e][o], int(tj[s])
+                )
+            )
     return out
 
 
@@ -132,11 +137,14 @@ def kink_split(trajs, max_deg, step_min, fresh_start=10_000_000):
         st = np.linalg.norm(np.diff(p, axis=0), axis=1)
         ok = (n[:-1] > 1e-12) & (n[1:] > 1e-12)
         cosang = np.ones(len(v) - 1)
-        cosang[ok] = np.clip((v[:-1][ok] * v[1:][ok]).sum(1) / (n[:-1][ok] * n[1:][ok]),
-                             -1, 1)
+        cosang[ok] = np.clip(
+            (v[:-1][ok] * v[1:][ok]).sum(1) / (n[:-1][ok] * n[1:][ok]), -1, 1
+        )
         ang = np.degrees(np.arccos(cosang))
         instep = np.concatenate([st[:1], st[:-1]])
-        bad = np.flatnonzero((ang > max_deg) & (instep > step_min) & (st > step_min)) + 1
+        bad = (
+            np.flatnonzero((ang > max_deg) & (instep > step_min) & (st > step_min)) + 1
+        )
         ncuts += len(bad)
         segs = np.split(np.arange(len(t)), bad)
         if len(segs) == 1:
@@ -163,40 +171,63 @@ def clean_trajectories(trajid, time, pos, settings, log=print):
     log = log or (lambda *a, **k: None)
     c = settings
     fps, sgw, sgo = c["fps"], c["sg_window"], c["sg_order"]
+    smooth_method = c.get("smooth_method", "spline")
+    spline_lam = c.get("spline_lam", None)
+
+    def _smooth(trajs, window=None, order=None):
+        if smooth_method == "savitzky_golay":
+            w = window if window is not None else sgw
+            o = order if order is not None else sgo
+            return savitzky_golay(trajs, fps, w, o, min_window=5)
+        return smoothing_spline(trajs, fps, lam=spline_lam)
+
     tj, rep = repair_arrays(
-        trajid, time, pos, max_gap=c["repair_max_gap"],
+        trajid,
+        time,
+        pos,
+        max_gap=c["repair_max_gap"],
         max_distance=c["repair_max_distance_mm"] * 1e-3,
-        link_percentile=c["repair_link_percentile"], cut=c["repair_cut"],
-        attach=c["repair_attach"], join=c["repair_join"],
-        cut_factor=c["repair_cut_factor"])
+        link_percentile=c["repair_link_percentile"],
+        cut=c["repair_cut"],
+        attach=c["repair_attach"],
+        join=c["repair_join"],
+        cut_factor=c["repair_cut_factor"],
+    )
     log(f"repair: cut={rep.get('links_cut')} joins={rep.get('joins')}")
-    s1 = savitzky_golay(trajectories_from_arrays(tj, time, pos), fps, sgw, sgo,
-                        min_window=5)
+    s1 = _smooth(trajectories_from_arrays(tj, time, pos))
     split, ncuts = kink_split(s1, c["kink_deg"], c["kink_step_mm"] / 1000.0)
-    log(f"kinksplit(>{c['kink_deg']}deg, steps>{c['kink_step_mm']}mm): "
-        f"{len(s1)} -> {len(split)} objs, {ncuts} cuts")
-    s2 = savitzky_golay(split, fps, sgw, sgo, min_window=5)
-    st = stitch_trajectories(s2, fps=fps, max_gap=c["gap1"],
-                             max_distance=c["dist1"], max_vel_diff=c["vd1"])
-    s2b = savitzky_golay(st, fps, sgw, sgo, min_window=5)
-    split2, _ = kink_split(s2b, c["kink_deg"], c["kink_step_mm"] / 1000.0,
-                           fresh_start=20_000_000)
-    s2c = savitzky_golay(split2, fps, sgw, sgo, min_window=5)
-    st2 = stitch_trajectories(s2c, fps=fps, max_gap=c["gap2"],
-                              max_distance=c["dist2"], max_vel_diff=c["vd2"])
-    if c["win_long"] > 0:
+    log(
+        f"kinksplit(>{c['kink_deg']}deg, steps>{c['kink_step_mm']}mm): "
+        f"{len(s1)} -> {len(split)} objs, {ncuts} cuts"
+    )
+    s2 = _smooth(split)
+    st = stitch_trajectories(
+        s2, fps=fps, max_gap=c["gap1"], max_distance=c["dist1"], max_vel_diff=c["vd1"]
+    )
+    s2b = _smooth(st)
+    split2, _ = kink_split(
+        s2b, c["kink_deg"], c["kink_step_mm"] / 1000.0, fresh_start=20_000_000
+    )
+    s2c = _smooth(split2)
+    st2 = stitch_trajectories(
+        s2c, fps=fps, max_gap=c["gap2"], max_distance=c["dist2"], max_vel_diff=c["vd2"]
+    )
+    if c["win_long"] > 0 and smooth_method == "savitzky_golay":
         short = [t for t in st2 if len(t) < c["len_long"]]
         long = [t for t in st2 if len(t) >= c["len_long"]]
-        s_short = savitzky_golay(short, fps, sgw, sgo, min_window=5)
-        s_long = savitzky_golay(long, fps, c["win_long"], c["order_long"],
-                                min_window=7)
+        s_short = _smooth(short)
+        s_long = savitzky_golay(long, fps, c["win_long"], c["order_long"], min_window=7)
         out = s_short + s_long
-        log(f"two-tier final smooth: {len(s_short)}x({sgw},{sgo}) + {len(s_long)}x"
-            f"({c['win_long']},{c['order_long']})")
+        log(
+            f"two-tier final smooth: {len(s_short)}x({sgw},{sgo}) + {len(s_long)}x"
+            f"({c['win_long']},{c['order_long']})"
+        )
     else:
-        out = savitzky_golay(st2, fps, sgw, sgo, min_window=5)
+        out = _smooth(st2)
     lens = np.array([len(t) for t in out]) if out else np.zeros(1, int)
-    log(f"final: n={len(out)} joined1={len(s2) - len(st)} "
+    log(
+        f"final: n={len(out)} joined1={len(s2) - len(st)} "
         f"joined2={len(s2c) - len(st2)} med={np.median(lens):.0f} "
-        f"max={lens.max()} rows={lens.sum()}")
+        f"max={lens.max()} rows={lens.sum()}"
+    )
     return out

{flowtracks-1.7.1.dev1 → flowtracks-1.8.1.dev1}/flowtracks/smoothing.py

@@ -6,7 +6,9 @@ Trajectory object because they precompute values that are dependent only on the
 smoothing method, and not on the trajectory itself, so they may be shared for
 processing a whole list of trajectories.
 """
+
 import numpy as np
+from scipy.interpolate import make_smoothing_spline
 
 from flowtracks.trajectory import Trajectory
 
@@ -70,12 +72,11 @@ def savitzky_golay(trajs, fps, window_size, order, min_window=None):
     min_window = int(min_window)
     if min_window % 2 != 1 or min_window < order + 2 or min_window > window_size:
         raise TypeError("min_window must be odd, >= order + 2 and <= window_size")
-    order_range = range(order+1)
+    order_range = range(order + 1)
 
     # Properties that should not be copied from the old trajectory because
     # they are obtained otherwise (or copied elsewhere).
-    smoothed_keys = ['pos', 'velocity', 'accel', 'acc_pp', 'time',
-        'trajid']
+    smoothed_keys = ["pos", "velocity", "accel", "acc_pp", "time", "trajid"]
 
     def coeffs(window):
         """(M, M_head, M_tail) for one window size. Least-squares polynomial
@@ -99,7 +100,11 @@ def savitzky_golay(trajs, fps, window_size, order, min_window=None):
                     rows[d] += fall * float(s) ** (p - d) * m[p] * fps**d
             return rows
 
-        return at(0), [at(i - half) for i in range(half)], [at(i + 1) for i in range(half)]
+        return (
+            at(0),
+            [at(i - half) for i in range(half)],
+            [at(i + 1) for i in range(half)],
+        )
 
     cache = {}
 
@@ -120,7 +125,9 @@ def savitzky_golay(trajs, fps, window_size, order, min_window=None):
             if np.all(steps == np.round(steps)):
                 step = np.gcd.reduce(np.round(steps).astype(np.int64))
             grid = np.arange(time[0], time[-1] + step / 2, step)
-            pos = np.column_stack([np.interp(grid, time, pos[:, k]) for k in range(pos.shape[1])])
+            pos = np.column_stack(
+                [np.interp(grid, time, pos[:, k]) for k in range(pos.shape[1])]
+            )
             observed = np.searchsorted(grid, time)
         if len(pos) < min_window:
             continue
@@ -131,12 +138,19 @@ def savitzky_golay(trajs, fps, window_size, order, min_window=None):
         half_window = (window - 1) // 2
 
         windows = np.lib.stride_tricks.sliding_window_view(
-            pos, window, axis=0)                         # (L-w+1, 3, window)
-        out = np.concatenate([
-            np.stack([windows[0] @ Mh.T for Mh in M_head]),
-            windows @ M.T,
-            np.stack([windows[-1] @ Mt.T for Mt in M_tail]),
-        ]) if half_window else windows @ M.T              # (L, 3, 4)
+            pos, window, axis=0
+        )  # (L-w+1, 3, window)
+        out = (
+            np.concatenate(
+                [
+                    np.stack([windows[0] @ Mh.T for Mh in M_head]),
+                    windows @ M.T,
+                    np.stack([windows[-1] @ Mt.T for Mt in M_tail]),
+                ]
+            )
+            if half_window
+            else windows @ M.T
+        )  # (L, 3, 4)
         out = out[observed]
 
         newpos = out[:, :, 0]
@@ -149,11 +163,73 @@ def savitzky_golay(trajs, fps, window_size, order, min_window=None):
         # Delta t treatment is in m_*.
         # Assumed that the first point is trimmed, the zeros are  just for
         # alignment.
-        nextvel = np.vstack((np.zeros(3), newvel + newacc/fps + jerk/2./fps**2))[:-1]
-        nextacc = np.vstack((np.zeros(3), newacc + jerk/fps))[:-1]
+        nextvel = np.vstack((np.zeros(3), newvel + newacc / fps + jerk / 2.0 / fps**2))[
+            :-1
+        ]
+        nextacc = np.vstack((np.zeros(3), newacc + jerk / fps))[:-1]
+
+        newtraj = Trajectory(
+            newpos,
+            newvel,
+            traj.time(),
+            traj.trajid(),
+            accel=newacc,
+            vel_pp=nextvel,
+            acc_pp=nextacc,
+        )
+
+        # Copy unsmoothed properties from old trajectory:
+        for k, v in traj.as_dict().items():
+            if k not in smoothed_keys:
+                newtraj.create_property(k, v)
+
+        new_trajs.append(newtraj)
+
+    return new_trajs
+
+
+def smoothing_spline(trajs, fps, lam=None):
+    r"""Smooth (and differentiate) trajectories with a cubic smoothing spline.
+
+    Fits, for each spatial coordinate, a cubic smoothing spline against time
+    using ``scipy.interpolate.make_smoothing_spline``. Unlike
+    :func:`savitzky_golay` this handles non-uniform frame spacing natively
+    (no fill-to-uniform-grid step) and exposes a single smoothing knob
+    ``lam`` (the penalty on the squared second derivative); when ``lam`` is
+    ``None`` Generalized Cross Validation chooses it automatically.
+
+    Parameters:
+    trajs - a list of Trajectory objects.
+    fps - frames per second, used to convert per-frame derivatives to
+        physical velocity (m/s) and acceleration (m/s^2).
+    lam - smoothing parameter (float) or None. None (default) lets GCV
+        pick it. Larger values give smoother curves.
+
+    Returns:
+    new_trajs - a list of Trajectory objects representing the smoothed
+        trajectories. Trajectories shorter than 5 points are discarded
+        (make_smoothing_spline requires at least 5 samples).
+    """
+    smoothed_keys = ["pos", "velocity", "accel", "acc_pp", "time", "trajid", "vel_pp"]
+
+    new_trajs = []
+    for traj in trajs:
+        time = np.asarray(traj.time(), dtype=float)
+        pos = np.asarray(traj.pos(), dtype=float)
+        if len(time) < 5:
+            continue
+        # make_smoothing_spline needs strictly increasing x.
+        if np.any(np.diff(time) <= 0):
+            continue
+        try:
+            spl = make_smoothing_spline(time, pos, lam=lam)
+        except (ValueError, np.linalg.LinAlgError):
+            continue
+        newpos = np.asarray(spl(time))
+        newvel = np.asarray(spl.derivative(1)(time)) * float(fps)
+        newacc = np.asarray(spl.derivative(2)(time)) * float(fps) ** 2
 
-        newtraj = Trajectory(newpos, newvel, traj.time(), traj.trajid(),
-            accel=newacc, vel_pp=nextvel, acc_pp = nextacc)
+        newtraj = Trajectory(newpos, newvel, traj.time(), traj.trajid(), accel=newacc)
 
         # Copy unsmoothed properties from old trajectory:
         for k, v in traj.as_dict().items():

{flowtracks-1.7.1.dev1 → flowtracks-1.8.1.dev1}/flowtracks.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flowtracks
-Version: 1.7.1.dev1
+Version: 1.8.1.dev1
 Summary: Library for handling 3D PTV trajectory databases and Lagrangian/Eulerian turbulence post-processing.
 Author-email: Yosef Meller <yosefm@gmail.com>
 License-Expression: GPL-3.0-only AND BSD-3-Clause

{flowtracks-1.7.1.dev1 → flowtracks-1.8.1.dev1}/flowtracks.egg-info/SOURCES.txt

@@ -702,6 +702,7 @@ docs/story/_marimo-studio/assets/zero-python/chunks/xychartDiagram-S5SC5T6Z-DJIF
 docs/story/_marimo-studio/views/story/config
 docs/story/_marimo-studio/views/story/zero-python/current
 examples/batch_Lagrangian_to_Eulerian.py
+examples/compare_smoothing.py
 examples/hdf5_scene_analysis.ipynb
 examples/linking_trajectories.ipynb
 examples/marimo_dual_rig_trajectories.py

{flowtracks-1.7.1.dev1 → flowtracks-1.8.1.dev1}/flowtracks.egg-info/scm_file_list.json

@@ -698,6 +698,7 @@
     "docs/story/_marimo-studio/views/story/zero-python/current",
     "docs/story/index.html",
     "examples/batch_Lagrangian_to_Eulerian.py",
+    "examples/compare_smoothing.py",
     "examples/hdf5_scene_analysis.ipynb",
     "examples/linking_trajectories.ipynb",
     "examples/marimo_dual_rig_trajectories.py",

flowtracks-1.8.1.dev1/flowtracks.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "1.8.0",
+  "distance": 1,
+  "node": "gc4c1d818357dc5f07a467fcd74cd1cb3b837fbe3",
+  "dirty": false,
+  "branch": "master",
+  "node_date": "2026-10-26"
+}

flowtracks-1.8.1.dev1/requriments.txt

@@ -0,0 +1 @@
+certifi>=2026.10.19