Add files using upload-large-folder tool

.venv/lib/python3.13/site-packages/sympy/printing/jscode.py

@@ -0,0 +1,332 @@
+"""
+Javascript code printer
+
+The JavascriptCodePrinter converts single SymPy expressions into single
+Javascript expressions, using the functions defined in the Javascript
+Math object where possible.
+
+"""
+
+from __future__ import annotations
+from typing import Any
+
+from sympy.core import S
+from sympy.core.numbers import equal_valued
+from sympy.printing.codeprinter import CodePrinter
+from sympy.printing.precedence import precedence, PRECEDENCE
+
+
+# dictionary mapping SymPy function to (argument_conditions, Javascript_function).
+# Used in JavascriptCodePrinter._print_Function(self)
+known_functions = {
+    'Abs': 'Math.abs',
+    'acos': 'Math.acos',
+    'acosh': 'Math.acosh',
+    'asin': 'Math.asin',
+    'asinh': 'Math.asinh',
+    'atan': 'Math.atan',
+    'atan2': 'Math.atan2',
+    'atanh': 'Math.atanh',
+    'ceiling': 'Math.ceil',
+    'cos': 'Math.cos',
+    'cosh': 'Math.cosh',
+    'exp': 'Math.exp',
+    'floor': 'Math.floor',
+    'log': 'Math.log',
+    'Max': 'Math.max',
+    'Min': 'Math.min',
+    'sign': 'Math.sign',
+    'sin': 'Math.sin',
+    'sinh': 'Math.sinh',
+    'tan': 'Math.tan',
+    'tanh': 'Math.tanh',
+}
+
+
+class JavascriptCodePrinter(CodePrinter):
+    """"A Printer to convert Python expressions to strings of JavaScript code
+    """
+    printmethod = '_javascript'
+    language = 'JavaScript'
+
+    _default_settings: dict[str, Any] = dict(CodePrinter._default_settings, **{
+        'precision': 17,
+        'user_functions': {},
+        'contract': True,
+    })
+
+    def __init__(self, settings={}):
+        CodePrinter.__init__(self, settings)
+        self.known_functions = dict(known_functions)
+        userfuncs = settings.get('user_functions', {})
+        self.known_functions.update(userfuncs)
+
+    def _rate_index_position(self, p):
+        return p*5
+
+    def _get_statement(self, codestring):
+        return "%s;" % codestring
+
+    def _get_comment(self, text):
+        return "// {}".format(text)
+
+    def _declare_number_const(self, name, value):
+        return "var {} = {};".format(name, value.evalf(self._settings['precision']))
+
+    def _format_code(self, lines):
+        return self.indent_code(lines)
+
+    def _traverse_matrix_indices(self, mat):
+        rows, cols = mat.shape
+        return ((i, j) for i in range(rows) for j in range(cols))
+
+    def _get_loop_opening_ending(self, indices):
+        open_lines = []
+        close_lines = []
+        loopstart = "for (var %(varble)s=%(start)s; %(varble)s<%(end)s; %(varble)s++){"
+        for i in indices:
+            # Javascript arrays start at 0 and end at dimension-1
+            open_lines.append(loopstart % {
+                'varble': self._print(i.label),
+                'start': self._print(i.lower),
+                'end': self._print(i.upper + 1)})
+            close_lines.append("}")
+        return open_lines, close_lines
+
+    def _print_Pow(self, expr):
+        PREC = precedence(expr)
+        if equal_valued(expr.exp, -1):
+            return '1/%s' % (self.parenthesize(expr.base, PREC))
+        elif equal_valued(expr.exp, 0.5):
+            return 'Math.sqrt(%s)' % self._print(expr.base)
+        elif expr.exp == S.One/3:
+            return 'Math.cbrt(%s)' % self._print(expr.base)
+        else:
+            return 'Math.pow(%s, %s)' % (self._print(expr.base),
+                                 self._print(expr.exp))
+
+    def _print_Rational(self, expr):
+        p, q = int(expr.p), int(expr.q)
+        return '%d/%d' % (p, q)
+
+    def _print_Mod(self, expr):
+        num, den = expr.args
+        PREC = precedence(expr)
+        snum, sden = [self.parenthesize(arg, PREC) for arg in expr.args]
+        # % is remainder (same sign as numerator), not modulo (same sign as
+        # denominator), in js. Hence, % only works as modulo if both numbers
+        # have the same sign
+        if (num.is_nonnegative and den.is_nonnegative or
+            num.is_nonpositive and den.is_nonpositive):
+            return f"{snum} % {sden}"
+        return f"(({snum} % {sden}) + {sden}) % {sden}"
+
+    def _print_Relational(self, expr):
+        lhs_code = self._print(expr.lhs)
+        rhs_code = self._print(expr.rhs)
+        op = expr.rel_op
+        return "{} {} {}".format(lhs_code, op, rhs_code)
+
+    def _print_Indexed(self, expr):
+        # calculate index for 1d array
+        dims = expr.shape
+        elem = S.Zero
+        offset = S.One
+        for i in reversed(range(expr.rank)):
+            elem += expr.indices[i]*offset
+            offset *= dims[i]
+        return "%s[%s]" % (self._print(expr.base.label), self._print(elem))
+
+    def _print_Exp1(self, expr):
+        return "Math.E"
+
+    def _print_Pi(self, expr):
+        return 'Math.PI'
+
+    def _print_Infinity(self, expr):
+        return 'Number.POSITIVE_INFINITY'
+
+    def _print_NegativeInfinity(self, expr):
+        return 'Number.NEGATIVE_INFINITY'
+
+    def _print_Piecewise(self, expr):
+        from sympy.codegen.ast import Assignment
+        if expr.args[-1].cond != True:
+            # We need the last conditional to be a True, otherwise the resulting
+            # function may not return a result.
+            raise ValueError("All Piecewise expressions must contain an "
+                             "(expr, True) statement to be used as a default "
+                             "condition. Without one, the generated "
+                             "expression may not evaluate to anything under "
+                             "some condition.")
+        lines = []
+        if expr.has(Assignment):
+            for i, (e, c) in enumerate(expr.args):
+                if i == 0:
+                    lines.append("if (%s) {" % self._print(c))
+                elif i == len(expr.args) - 1 and c == True:
+                    lines.append("else {")
+                else:
+                    lines.append("else if (%s) {" % self._print(c))
+                code0 = self._print(e)
+                lines.append(code0)
+                lines.append("}")
+            return "\n".join(lines)
+        else:
+            # The piecewise was used in an expression, need to do inline
+            # operators. This has the downside that inline operators will
+            # not work for statements that span multiple lines (Matrix or
+            # Indexed expressions).
+            ecpairs = ["((%s) ? (\n%s\n)\n" % (self._print(c), self._print(e))
+                    for e, c in expr.args[:-1]]
+            last_line = ": (\n%s\n)" % self._print(expr.args[-1].expr)
+            return ": ".join(ecpairs) + last_line + " ".join([")"*len(ecpairs)])
+
+    def _print_MatrixElement(self, expr):
+        return "{}[{}]".format(self.parenthesize(expr.parent,
+            PRECEDENCE["Atom"], strict=True),
+            expr.j + expr.i*expr.parent.shape[1])
+
+    def indent_code(self, code):
+        """Accepts a string of code or a list of code lines"""
+
+        if isinstance(code, str):
+            code_lines = self.indent_code(code.splitlines(True))
+            return ''.join(code_lines)
+
+        tab = "   "
+        inc_token = ('{', '(', '{\n', '(\n')
+        dec_token = ('}', ')')
+
+        code = [ line.lstrip(' \t') for line in code ]
+
+        increase = [ int(any(map(line.endswith, inc_token))) for line in code ]
+        decrease = [ int(any(map(line.startswith, dec_token)))
+                     for line in code ]
+
+        pretty = []
+        level = 0
+        for n, line in enumerate(code):
+            if line in ('', '\n'):
+                pretty.append(line)
+                continue
+            level -= decrease[n]
+            pretty.append("%s%s" % (tab*level, line))
+            level += increase[n]
+        return pretty
+
+
+def jscode(expr, assign_to=None, **settings):
+    """Converts an expr to a string of javascript code
+
+    Parameters
+    ==========
+
+    expr : Expr
+        A SymPy expression to be converted.
+    assign_to : optional
+        When given, the argument is used as the name of the variable to which
+        the expression is assigned. Can be a string, ``Symbol``,
+        ``MatrixSymbol``, or ``Indexed`` type. This is helpful in case of
+        line-wrapping, or for expressions that generate multi-line statements.
+    precision : integer, optional
+        The precision for numbers such as pi [default=15].
+    user_functions : dict, optional
+        A dictionary where keys are ``FunctionClass`` instances and values are
+        their string representations. Alternatively, the dictionary value can
+        be a list of tuples i.e. [(argument_test, js_function_string)]. See
+        below for examples.
+    human : bool, optional
+        If True, the result is a single string that may contain some constant
+        declarations for the number symbols. If False, the same information is
+        returned in a tuple of (symbols_to_declare, not_supported_functions,
+        code_text). [default=True].
+    contract: bool, optional
+        If True, ``Indexed`` instances are assumed to obey tensor contraction
+        rules and the corresponding nested loops over indices are generated.
+        Setting contract=False will not generate loops, instead the user is
+        responsible to provide values for the indices in the code.
+        [default=True].
+
+    Examples
+    ========
+
+    >>> from sympy import jscode, symbols, Rational, sin, ceiling, Abs
+    >>> x, tau = symbols("x, tau")
+    >>> jscode((2*tau)**Rational(7, 2))
+    '8*Math.sqrt(2)*Math.pow(tau, 7/2)'
+    >>> jscode(sin(x), assign_to="s")
+    's = Math.sin(x);'
+
+    Custom printing can be defined for certain types by passing a dictionary of
+    "type" : "function" to the ``user_functions`` kwarg. Alternatively, the
+    dictionary value can be a list of tuples i.e. [(argument_test,
+    js_function_string)].
+
+    >>> custom_functions = {
+    ...   "ceiling": "CEIL",
+    ...   "Abs": [(lambda x: not x.is_integer, "fabs"),
+    ...           (lambda x: x.is_integer, "ABS")]
+    ... }
+    >>> jscode(Abs(x) + ceiling(x), user_functions=custom_functions)
+    'fabs(x) + CEIL(x)'
+
+    ``Piecewise`` expressions are converted into conditionals. If an
+    ``assign_to`` variable is provided an if statement is created, otherwise
+    the ternary operator is used. Note that if the ``Piecewise`` lacks a
+    default term, represented by ``(expr, True)`` then an error will be thrown.
+    This is to prevent generating an expression that may not evaluate to
+    anything.
+
+    >>> from sympy import Piecewise
+    >>> expr = Piecewise((x + 1, x > 0), (x, True))
+    >>> print(jscode(expr, tau))
+    if (x > 0) {
+       tau = x + 1;
+    }
+    else {
+       tau = x;
+    }
+
+    Support for loops is provided through ``Indexed`` types. With
+    ``contract=True`` these expressions will be turned into loops, whereas
+    ``contract=False`` will just print the assignment expression that should be
+    looped over:
+
+    >>> from sympy import Eq, IndexedBase, Idx
+    >>> len_y = 5
+    >>> y = IndexedBase('y', shape=(len_y,))
+    >>> t = IndexedBase('t', shape=(len_y,))
+    >>> Dy = IndexedBase('Dy', shape=(len_y-1,))
+    >>> i = Idx('i', len_y-1)
+    >>> e=Eq(Dy[i], (y[i+1]-y[i])/(t[i+1]-t[i]))
+    >>> jscode(e.rhs, assign_to=e.lhs, contract=False)
+    'Dy[i] = (y[i + 1] - y[i])/(t[i + 1] - t[i]);'
+
+    Matrices are also supported, but a ``MatrixSymbol`` of the same dimensions
+    must be provided to ``assign_to``. Note that any expression that can be
+    generated normally can also exist inside a Matrix:
+
+    >>> from sympy import Matrix, MatrixSymbol
+    >>> mat = Matrix([x**2, Piecewise((x + 1, x > 0), (x, True)), sin(x)])
+    >>> A = MatrixSymbol('A', 3, 1)
+    >>> print(jscode(mat, A))
+    A[0] = Math.pow(x, 2);
+    if (x > 0) {
+       A[1] = x + 1;
+    }
+    else {
+       A[1] = x;
+    }
+    A[2] = Math.sin(x);
+    """
+
+    return JavascriptCodePrinter(settings).doprint(expr, assign_to)
+
+
+def print_jscode(expr, **settings):
+    """Prints the Javascript representation of the given expression.
+
+       See jscode for the meaning of the optional arguments.
+    """
+    print(jscode(expr, **settings))

.venv/lib/python3.13/site-packages/sympy/printing/numpy.py

@@ -0,0 +1,541 @@
+from sympy.core import S
+from sympy.core.function import Lambda
+from sympy.core.power import Pow
+from .pycode import PythonCodePrinter, _known_functions_math, _print_known_const, _print_known_func, _unpack_integral_limits, ArrayPrinter
+from .codeprinter import CodePrinter
+
+
+_not_in_numpy = 'erf erfc factorial gamma loggamma'.split()
+_in_numpy = [(k, v) for k, v in _known_functions_math.items() if k not in _not_in_numpy]
+_known_functions_numpy = dict(_in_numpy, **{
+    'acos': 'arccos',
+    'acosh': 'arccosh',
+    'asin': 'arcsin',
+    'asinh': 'arcsinh',
+    'atan': 'arctan',
+    'atan2': 'arctan2',
+    'atanh': 'arctanh',
+    'exp2': 'exp2',
+    'sign': 'sign',
+    'logaddexp': 'logaddexp',
+    'logaddexp2': 'logaddexp2',
+    'isinf': 'isinf',
+    'isnan': 'isnan',
+
+})
+_known_constants_numpy = {
+    'Exp1': 'e',
+    'Pi': 'pi',
+    'EulerGamma': 'euler_gamma',
+    'NaN': 'nan',
+    'Infinity': 'inf',
+}
+
+_numpy_known_functions = {k: 'numpy.' + v for k, v in _known_functions_numpy.items()}
+_numpy_known_constants = {k: 'numpy.' + v for k, v in _known_constants_numpy.items()}
+
+class NumPyPrinter(ArrayPrinter, PythonCodePrinter):
+    """
+    Numpy printer which handles vectorized piecewise functions,
+    logical operators, etc.
+    """
+
+    _module = 'numpy'
+    _kf = _numpy_known_functions
+    _kc = _numpy_known_constants
+
+    def __init__(self, settings=None):
+        """
+        `settings` is passed to CodePrinter.__init__()
+        `module` specifies the array module to use, currently 'NumPy', 'CuPy'
+        or 'JAX'.
+        """
+        self.language = "Python with {}".format(self._module)
+        self.printmethod = "_{}code".format(self._module)
+
+        self._kf = {**PythonCodePrinter._kf, **self._kf}
+
+        super().__init__(settings=settings)
+
+
+    def _print_seq(self, seq):
+        "General sequence printer: converts to tuple"
+        # Print tuples here instead of lists because numba supports
+        #     tuples in nopython mode.
+        delimiter=', '
+        return '({},)'.format(delimiter.join(self._print(item) for item in seq))
+
+    def _print_NegativeInfinity(self, expr):
+        return '-' + self._print(S.Infinity)
+
+    def _print_MatMul(self, expr):
+        "Matrix multiplication printer"
+        if expr.as_coeff_matrices()[0] is not S.One:
+            expr_list = expr.as_coeff_matrices()[1]+[(expr.as_coeff_matrices()[0])]
+            return '({})'.format(').dot('.join(self._print(i) for i in expr_list))
+        return '({})'.format(').dot('.join(self._print(i) for i in expr.args))
+
+    def _print_MatPow(self, expr):
+        "Matrix power printer"
+        return '{}({}, {})'.format(self._module_format(self._module + '.linalg.matrix_power'),
+            self._print(expr.args[0]), self._print(expr.args[1]))
+
+    def _print_Inverse(self, expr):
+        "Matrix inverse printer"
+        return '{}({})'.format(self._module_format(self._module + '.linalg.inv'),
+            self._print(expr.args[0]))
+
+    def _print_DotProduct(self, expr):
+        # DotProduct allows any shape order, but numpy.dot does matrix
+        # multiplication, so we have to make sure it gets 1 x n by n x 1.
+        arg1, arg2 = expr.args
+        if arg1.shape[0] != 1:
+            arg1 = arg1.T
+        if arg2.shape[1] != 1:
+            arg2 = arg2.T
+
+        return "%s(%s, %s)" % (self._module_format(self._module + '.dot'),
+                               self._print(arg1),
+                               self._print(arg2))
+
+    def _print_MatrixSolve(self, expr):
+        return "%s(%s, %s)" % (self._module_format(self._module + '.linalg.solve'),
+                               self._print(expr.matrix),
+                               self._print(expr.vector))
+
+    def _print_ZeroMatrix(self, expr):
+        return '{}({})'.format(self._module_format(self._module + '.zeros'),
+            self._print(expr.shape))
+
+    def _print_OneMatrix(self, expr):
+        return '{}({})'.format(self._module_format(self._module + '.ones'),
+            self._print(expr.shape))
+
+    def _print_FunctionMatrix(self, expr):
+        from sympy.abc import i, j
+        lamda = expr.lamda
+        if not isinstance(lamda, Lambda):
+            lamda = Lambda((i, j), lamda(i, j))
+        return '{}(lambda {}: {}, {})'.format(self._module_format(self._module + '.fromfunction'),
+            ', '.join(self._print(arg) for arg in lamda.args[0]),
+            self._print(lamda.args[1]), self._print(expr.shape))
+
+    def _print_HadamardProduct(self, expr):
+        func = self._module_format(self._module + '.multiply')
+        return ''.join('{}({}, '.format(func, self._print(arg)) \
+            for arg in expr.args[:-1]) + "{}{}".format(self._print(expr.args[-1]),
+            ')' * (len(expr.args) - 1))
+
+    def _print_KroneckerProduct(self, expr):
+        func = self._module_format(self._module + '.kron')
+        return ''.join('{}({}, '.format(func, self._print(arg)) \
+            for arg in expr.args[:-1]) + "{}{}".format(self._print(expr.args[-1]),
+            ')' * (len(expr.args) - 1))
+
+    def _print_Adjoint(self, expr):
+        return '{}({}({}))'.format(
+            self._module_format(self._module + '.conjugate'),
+            self._module_format(self._module + '.transpose'),
+            self._print(expr.args[0]))
+
+    def _print_DiagonalOf(self, expr):
+        vect = '{}({})'.format(
+            self._module_format(self._module + '.diag'),
+            self._print(expr.arg))
+        return '{}({}, (-1, 1))'.format(
+            self._module_format(self._module + '.reshape'), vect)
+
+    def _print_DiagMatrix(self, expr):
+        return '{}({})'.format(self._module_format(self._module + '.diagflat'),
+            self._print(expr.args[0]))
+
+    def _print_DiagonalMatrix(self, expr):
+        return '{}({}, {}({}, {}))'.format(self._module_format(self._module + '.multiply'),
+            self._print(expr.arg), self._module_format(self._module + '.eye'),
+            self._print(expr.shape[0]), self._print(expr.shape[1]))
+
+    def _print_Piecewise(self, expr):
+        "Piecewise function printer"
+        from sympy.logic.boolalg import ITE, simplify_logic
+        def print_cond(cond):
+            """ Problem having an ITE in the cond. """
+            if cond.has(ITE):
+                return self._print(simplify_logic(cond))
+            else:
+                return self._print(cond)
+        exprs = '[{}]'.format(','.join(self._print(arg.expr) for arg in expr.args))
+        conds = '[{}]'.format(','.join(print_cond(arg.cond) for arg in expr.args))
+        # If [default_value, True] is a (expr, cond) sequence in a Piecewise object
+        #     it will behave the same as passing the 'default' kwarg to select()
+        #     *as long as* it is the last element in expr.args.
+        # If this is not the case, it may be triggered prematurely.
+        return '{}({}, {}, default={})'.format(
+            self._module_format(self._module + '.select'), conds, exprs,
+            self._print(S.NaN))
+
+    def _print_Relational(self, expr):
+        "Relational printer for Equality and Unequality"
+        op = {
+            '==' :'equal',
+            '!=' :'not_equal',
+            '<'  :'less',
+            '<=' :'less_equal',
+            '>'  :'greater',
+            '>=' :'greater_equal',
+        }
+        if expr.rel_op in op:
+            lhs = self._print(expr.lhs)
+            rhs = self._print(expr.rhs)
+            return '{op}({lhs}, {rhs})'.format(op=self._module_format(self._module + '.'+op[expr.rel_op]),
+                                               lhs=lhs, rhs=rhs)
+        return super()._print_Relational(expr)
+
+    def _print_And(self, expr):
+        "Logical And printer"
+        # We have to override LambdaPrinter because it uses Python 'and' keyword.
+        # If LambdaPrinter didn't define it, we could use StrPrinter's
+        # version of the function and add 'logical_and' to NUMPY_TRANSLATIONS.
+        return '{}.reduce(({}))'.format(self._module_format(self._module + '.logical_and'), ','.join(self._print(i) for i in expr.args))
+
+    def _print_Or(self, expr):
+        "Logical Or printer"
+        # We have to override LambdaPrinter because it uses Python 'or' keyword.
+        # If LambdaPrinter didn't define it, we could use StrPrinter's
+        # version of the function and add 'logical_or' to NUMPY_TRANSLATIONS.
+        return '{}.reduce(({}))'.format(self._module_format(self._module + '.logical_or'), ','.join(self._print(i) for i in expr.args))
+
+    def _print_Not(self, expr):
+        "Logical Not printer"
+        # We have to override LambdaPrinter because it uses Python 'not' keyword.
+        # If LambdaPrinter didn't define it, we would still have to define our
+        #     own because StrPrinter doesn't define it.
+        return '{}({})'.format(self._module_format(self._module + '.logical_not'), ','.join(self._print(i) for i in expr.args))
+
+    def _print_Pow(self, expr, rational=False):
+        # XXX Workaround for negative integer power error
+        if expr.exp.is_integer and expr.exp.is_negative:
+            expr = Pow(expr.base, expr.exp.evalf(), evaluate=False)
+        return self._hprint_Pow(expr, rational=rational, sqrt=self._module + '.sqrt')
+
+    def _helper_minimum_maximum(self, op: str, *args):
+        if len(args) == 0:
+            raise NotImplementedError(f"Need at least one argument for {op}")
+        elif len(args) == 1:
+            return self._print(args[0])
+        _reduce = self._module_format('functools.reduce')
+        s_args = [self._print(arg) for arg in args]
+        return f"{_reduce}({op}, [{', '.join(s_args)}])"
+
+    def _print_Min(self, expr):
+        return self._print_minimum(expr)
+
+    def _print_amin(self, expr):
+        return '{}({}, axis={})'.format(self._module_format(self._module + '.amin'), self._print(expr.array), self._print(expr.axis))
+
+    def _print_minimum(self, expr):
+        op = self._module_format(self._module + '.minimum')
+        return self._helper_minimum_maximum(op, *expr.args)
+
+    def _print_Max(self, expr):
+        return self._print_maximum(expr)
+
+    def _print_amax(self, expr):
+        return '{}({}, axis={})'.format(self._module_format(self._module + '.amax'), self._print(expr.array), self._print(expr.axis))
+
+    def _print_maximum(self, expr):
+        op = self._module_format(self._module + '.maximum')
+        return self._helper_minimum_maximum(op, *expr.args)
+
+    def _print_arg(self, expr):
+        return "%s(%s)" % (self._module_format(self._module + '.angle'), self._print(expr.args[0]))
+
+    def _print_im(self, expr):
+        return "%s(%s)" % (self._module_format(self._module + '.imag'), self._print(expr.args[0]))
+
+    def _print_Mod(self, expr):
+        return "%s(%s)" % (self._module_format(self._module + '.mod'), ', '.join(
+            (self._print(arg) for arg in expr.args)))
+
+    def _print_re(self, expr):
+        return "%s(%s)" % (self._module_format(self._module + '.real'), self._print(expr.args[0]))
+
+    def _print_sinc(self, expr):
+        return "%s(%s)" % (self._module_format(self._module + '.sinc'), self._print(expr.args[0]/S.Pi))
+
+    def _print_MatrixBase(self, expr):
+        if 0 in expr.shape:
+            func = self._module_format(f'{self._module}.{self._zeros}')
+            return f"{func}({self._print(expr.shape)})"
+        func = self.known_functions.get(expr.__class__.__name__, None)
+        if func is None:
+            func = self._module_format(f'{self._module}.array')
+        return "%s(%s)" % (func, self._print(expr.tolist()))
+
+    def _print_Identity(self, expr):
+        shape = expr.shape
+        if all(dim.is_Integer for dim in shape):
+            return "%s(%s)" % (self._module_format(self._module + '.eye'), self._print(expr.shape[0]))
+        else:
+            raise NotImplementedError("Symbolic matrix dimensions are not yet supported for identity matrices")
+
+    def _print_BlockMatrix(self, expr):
+        return '{}({})'.format(self._module_format(self._module + '.block'),
+                                 self._print(expr.args[0].tolist()))
+
+    def _print_NDimArray(self, expr):
+        if expr.rank() == 0:
+            func = self._module_format(f'{self._module}.array')
+            return f"{func}({self._print(expr[()])})"
+        if 0 in expr.shape:
+            func = self._module_format(f'{self._module}.{self._zeros}')
+            return f"{func}({self._print(expr.shape)})"
+        func = self._module_format(f'{self._module}.array')
+        return f"{func}({self._print(expr.tolist())})"
+
+    _add = "add"
+    _einsum = "einsum"
+    _transpose = "transpose"
+    _ones = "ones"
+    _zeros = "zeros"
+
+    _print_lowergamma = CodePrinter._print_not_supported
+    _print_uppergamma = CodePrinter._print_not_supported
+    _print_fresnelc = CodePrinter._print_not_supported
+    _print_fresnels = CodePrinter._print_not_supported
+
+for func in _numpy_known_functions:
+    setattr(NumPyPrinter, f'_print_{func}', _print_known_func)
+
+for const in _numpy_known_constants:
+    setattr(NumPyPrinter, f'_print_{const}', _print_known_const)
+
+
+_known_functions_scipy_special = {
+    'Ei': 'expi',
+    'erf': 'erf',
+    'erfc': 'erfc',
+    'besselj': 'jv',
+    'bessely': 'yv',
+    'besseli': 'iv',
+    'besselk': 'kv',
+    'cosm1': 'cosm1',
+    'powm1': 'powm1',
+    'factorial': 'factorial',
+    'gamma': 'gamma',
+    'loggamma': 'gammaln',
+    'digamma': 'psi',
+    'polygamma': 'polygamma',
+    'RisingFactorial': 'poch',
+    'jacobi': 'eval_jacobi',
+    'gegenbauer': 'eval_gegenbauer',
+    'chebyshevt': 'eval_chebyt',
+    'chebyshevu': 'eval_chebyu',
+    'legendre': 'eval_legendre',
+    'hermite': 'eval_hermite',
+    'laguerre': 'eval_laguerre',
+    'assoc_laguerre': 'eval_genlaguerre',
+    'beta': 'beta',
+    'LambertW' : 'lambertw',
+}
+
+_known_constants_scipy_constants = {
+    'GoldenRatio': 'golden_ratio',
+    'Pi': 'pi',
+}
+_scipy_known_functions = {k : "scipy.special." + v for k, v in _known_functions_scipy_special.items()}
+_scipy_known_constants = {k : "scipy.constants." + v for k, v in _known_constants_scipy_constants.items()}
+
+class SciPyPrinter(NumPyPrinter):
+
+    _kf = {**NumPyPrinter._kf, **_scipy_known_functions}
+    _kc = {**NumPyPrinter._kc, **_scipy_known_constants}
+
+    def __init__(self, settings=None):
+        super().__init__(settings=settings)
+        self.language = "Python with SciPy and NumPy"
+
+    def _print_SparseRepMatrix(self, expr):
+        i, j, data = [], [], []
+        for (r, c), v in expr.todok().items():
+            i.append(r)
+            j.append(c)
+            data.append(v)
+
+        return "{name}(({data}, ({i}, {j})), shape={shape})".format(
+            name=self._module_format('scipy.sparse.coo_matrix'),
+            data=data, i=i, j=j, shape=expr.shape
+        )
+
+    _print_ImmutableSparseMatrix = _print_SparseRepMatrix
+
+    # SciPy's lpmv has a different order of arguments from assoc_legendre
+    def _print_assoc_legendre(self, expr):
+        return "{0}({2}, {1}, {3})".format(
+            self._module_format('scipy.special.lpmv'),
+            self._print(expr.args[0]),
+            self._print(expr.args[1]),
+            self._print(expr.args[2]))
+
+    def _print_lowergamma(self, expr):
+        return "{0}({2})*{1}({2}, {3})".format(
+            self._module_format('scipy.special.gamma'),
+            self._module_format('scipy.special.gammainc'),
+            self._print(expr.args[0]),
+            self._print(expr.args[1]))
+
+    def _print_uppergamma(self, expr):
+        return "{0}({2})*{1}({2}, {3})".format(
+            self._module_format('scipy.special.gamma'),
+            self._module_format('scipy.special.gammaincc'),
+            self._print(expr.args[0]),
+            self._print(expr.args[1]))
+
+    def _print_betainc(self, expr):
+        betainc = self._module_format('scipy.special.betainc')
+        beta = self._module_format('scipy.special.beta')
+        args = [self._print(arg) for arg in expr.args]
+        return f"({betainc}({args[0]}, {args[1]}, {args[3]}) - {betainc}({args[0]}, {args[1]}, {args[2]})) \
+            * {beta}({args[0]}, {args[1]})"
+
+    def _print_betainc_regularized(self, expr):
+        return "{0}({1}, {2}, {4}) - {0}({1}, {2}, {3})".format(
+            self._module_format('scipy.special.betainc'),
+            self._print(expr.args[0]),
+            self._print(expr.args[1]),
+            self._print(expr.args[2]),
+            self._print(expr.args[3]))
+
+    def _print_fresnels(self, expr):
+        return "{}({})[0]".format(
+                self._module_format("scipy.special.fresnel"),
+                self._print(expr.args[0]))
+
+    def _print_fresnelc(self, expr):
+        return "{}({})[1]".format(
+                self._module_format("scipy.special.fresnel"),
+                self._print(expr.args[0]))
+
+    def _print_airyai(self, expr):
+        return "{}({})[0]".format(
+                self._module_format("scipy.special.airy"),
+                self._print(expr.args[0]))
+
+    def _print_airyaiprime(self, expr):
+        return "{}({})[1]".format(
+                self._module_format("scipy.special.airy"),
+                self._print(expr.args[0]))
+
+    def _print_airybi(self, expr):
+        return "{}({})[2]".format(
+                self._module_format("scipy.special.airy"),
+                self._print(expr.args[0]))
+
+    def _print_airybiprime(self, expr):
+        return "{}({})[3]".format(
+                self._module_format("scipy.special.airy"),
+                self._print(expr.args[0]))
+
+    def _print_bernoulli(self, expr):
+        # scipy's bernoulli is inconsistent with SymPy's so rewrite
+        return self._print(expr._eval_rewrite_as_zeta(*expr.args))
+
+    def _print_harmonic(self, expr):
+        return self._print(expr._eval_rewrite_as_zeta(*expr.args))
+
+    def _print_Integral(self, e):
+        integration_vars, limits = _unpack_integral_limits(e)
+
+        if len(limits) == 1:
+            # nicer (but not necessary) to prefer quad over nquad for 1D case
+            module_str = self._module_format("scipy.integrate.quad")
+            limit_str = "%s, %s" % tuple(map(self._print, limits[0]))
+        else:
+            module_str = self._module_format("scipy.integrate.nquad")
+            limit_str = "({})".format(", ".join(
+                "(%s, %s)" % tuple(map(self._print, l)) for l in limits))
+
+        return "{}(lambda {}: {}, {})[0]".format(
+                module_str,
+                ", ".join(map(self._print, integration_vars)),
+                self._print(e.args[0]),
+                limit_str)
+
+    def _print_Si(self, expr):
+        return "{}({})[0]".format(
+                self._module_format("scipy.special.sici"),
+                self._print(expr.args[0]))
+
+    def _print_Ci(self, expr):
+        return "{}({})[1]".format(
+                self._module_format("scipy.special.sici"),
+                self._print(expr.args[0]))
+
+for func in _scipy_known_functions:
+    setattr(SciPyPrinter, f'_print_{func}', _print_known_func)
+
+for const in _scipy_known_constants:
+    setattr(SciPyPrinter, f'_print_{const}', _print_known_const)
+
+
+_cupy_known_functions = {k : "cupy." + v for k, v in _known_functions_numpy.items()}
+_cupy_known_constants = {k : "cupy." + v for k, v in _known_constants_numpy.items()}
+
+class CuPyPrinter(NumPyPrinter):
+    """
+    CuPy printer which handles vectorized piecewise functions,
+    logical operators, etc.
+    """
+
+    _module = 'cupy'
+    _kf = _cupy_known_functions
+    _kc = _cupy_known_constants
+
+    def __init__(self, settings=None):
+        super().__init__(settings=settings)
+
+for func in _cupy_known_functions:
+    setattr(CuPyPrinter, f'_print_{func}', _print_known_func)
+
+for const in _cupy_known_constants:
+    setattr(CuPyPrinter, f'_print_{const}', _print_known_const)
+
+
+_jax_known_functions = {k: 'jax.numpy.' + v for k, v in _known_functions_numpy.items()}
+_jax_known_constants = {k: 'jax.numpy.' + v for k, v in _known_constants_numpy.items()}
+
+class JaxPrinter(NumPyPrinter):
+    """
+    JAX printer which handles vectorized piecewise functions,
+    logical operators, etc.
+    """
+    _module = "jax.numpy"
+
+    _kf = _jax_known_functions
+    _kc = _jax_known_constants
+
+    def __init__(self, settings=None):
+        super().__init__(settings=settings)
+        self.printmethod = '_jaxcode'
+
+    # These need specific override to allow for the lack of "jax.numpy.reduce"
+    def _print_And(self, expr):
+        "Logical And printer"
+        return "{}({}.asarray([{}]), axis=0)".format(
+            self._module_format(self._module + ".all"),
+            self._module_format(self._module),
+            ",".join(self._print(i) for i in expr.args),
+        )
+
+    def _print_Or(self, expr):
+        "Logical Or printer"
+        return "{}({}.asarray([{}]), axis=0)".format(
+            self._module_format(self._module + ".any"),
+            self._module_format(self._module),
+            ",".join(self._print(i) for i in expr.args),
+        )
+
+for func in _jax_known_functions:
+    setattr(JaxPrinter, f'_print_{func}', _print_known_func)
+
+for const in _jax_known_constants:
+    setattr(JaxPrinter, f'_print_{const}', _print_known_const)

video/video_2026-02-18T12-43-09Z/packhouse1_inline3/predictions/000078.json

@@ -0,0 +1,30 @@
+{
+  "frame_idx": 78,
+  "image_key": "video/video_2026-02-18T12-43-09Z/packhouse1_inline3/annotated.mp4",
+  "predictions": [
+    {
+      "frame_idx": 78,
+      "class": "box",
+      "bbox": [
+        697.0,
+        87.0,
+        1280.0,
+        555.0
+      ],
+      "score": 0.9500463008880615,
+      "track_id": "auto-0"
+    },
+    {
+      "frame_idx": 78,
+      "class": "box",
+      "bbox": [
+        0.0,
+        274.0,
+        81.0,
+        447.0
+      ],
+      "score": 0.5330366492271423,
+      "track_id": "auto-1"
+    }
+  ]
+}

video/video_2026-02-18T12-43-09Z/packhouse1_inline3/predictions/000428.json

@@ -0,0 +1,5 @@
+{
+  "frame_idx": 428,
+  "image_key": "video/video_2026-02-18T12-43-09Z/packhouse1_inline3/annotated.mp4",
+  "predictions": []
+}

video/video_2026-02-18T12-43-09Z/packhouse1_inline3/predictions/001014.json

@@ -0,0 +1,5 @@
+{
+  "frame_idx": 1014,
+  "image_key": "video/video_2026-02-18T12-43-09Z/packhouse1_inline3/annotated.mp4",
+  "predictions": []
+}

video/video_2026-02-18T12-43-09Z/packhouse1_inline3/predictions/001151.json

@@ -0,0 +1,5 @@
+{
+  "frame_idx": 1151,
+  "image_key": "video/video_2026-02-18T12-43-09Z/packhouse1_inline3/annotated.mp4",
+  "predictions": []
+}

video/video_2026-02-18T12-43-09Z/packhouse1_inline3/predictions/001239.json

@@ -0,0 +1,5 @@
+{
+  "frame_idx": 1239,
+  "image_key": "video/video_2026-02-18T12-43-09Z/packhouse1_inline3/annotated.mp4",
+  "predictions": []
+}

video/video_2026-02-18T12-43-09Z/packhouse1_inline3/predictions/001393.json

@@ -0,0 +1,5 @@
+{
+  "frame_idx": 1393,
+  "image_key": "video/video_2026-02-18T12-43-09Z/packhouse1_inline3/annotated.mp4",
+  "predictions": []
+}

video/video_2026-02-18T12-43-09Z/packhouse1_inline3/predictions/001444.json

@@ -0,0 +1,5 @@
+{
+  "frame_idx": 1444,
+  "image_key": "video/video_2026-02-18T12-43-09Z/packhouse1_inline3/annotated.mp4",
+  "predictions": []
+}

video/video_2026-02-18T12-43-09Z/packhouse1_inline3/predictions/001501.json

@@ -0,0 +1,5 @@
+{
+  "frame_idx": 1501,
+  "image_key": "video/video_2026-02-18T12-43-09Z/packhouse1_inline3/annotated.mp4",
+  "predictions": []
+}

video/video_2026-02-18T12-43-09Z/packhouse1_inline3/predictions/001669.json

@@ -0,0 +1,5 @@
+{
+  "frame_idx": 1669,
+  "image_key": "video/video_2026-02-18T12-43-09Z/packhouse1_inline3/annotated.mp4",
+  "predictions": []
+}

video/video_2026-02-18T12-43-09Z/packhouse1_inline3/predictions/002415.json

@@ -0,0 +1,5 @@
+{
+  "frame_idx": 2415,
+  "image_key": "video/video_2026-02-18T12-43-09Z/packhouse1_inline3/annotated.mp4",
+  "predictions": []
+}

video/video_2026-02-18T12-43-09Z/packhouse1_inline3/predictions/002946.json

@@ -0,0 +1,5 @@
+{
+  "frame_idx": 2946,
+  "image_key": "video/video_2026-02-18T12-43-09Z/packhouse1_inline3/annotated.mp4",
+  "predictions": []
+}

video/video_2026-02-18T12-43-09Z/packhouse1_inline3/predictions/003029.json

@@ -0,0 +1,5 @@
+{
+  "frame_idx": 3029,
+  "image_key": "video/video_2026-02-18T12-43-09Z/packhouse1_inline3/annotated.mp4",
+  "predictions": []
+}

video/video_2026-02-18T12-43-09Z/packhouse1_inline3/predictions/003183.json

@@ -0,0 +1,18 @@
+{
+  "frame_idx": 3183,
+  "image_key": "video/video_2026-02-18T12-43-09Z/packhouse1_inline3/annotated.mp4",
+  "predictions": [
+    {
+      "frame_idx": 3183,
+      "class": "box",
+      "bbox": [
+        0.0,
+        166.0,
+        209.0,
+        464.0
+      ],
+      "score": 0.8340244889259338,
+      "track_id": "auto-0"
+    }
+  ]
+}

video/video_2026-02-18T12-43-09Z/packhouse1_inline3/predictions/003204.json

@@ -0,0 +1,18 @@
+{
+  "frame_idx": 3204,
+  "image_key": "video/video_2026-02-18T12-43-09Z/packhouse1_inline3/annotated.mp4",
+  "predictions": [
+    {
+      "frame_idx": 3204,
+      "class": "box",
+      "bbox": [
+        771.0,
+        0.0,
+        1277.0,
+        456.0
+      ],
+      "score": 0.9126523733139038,
+      "track_id": "auto-0"
+    }
+  ]
+}

video/video_2026-02-18T12-43-09Z/packhouse1_inline3/predictions/003479.json

@@ -0,0 +1,5 @@
+{
+  "frame_idx": 3479,
+  "image_key": "video/video_2026-02-18T12-43-09Z/packhouse1_inline3/annotated.mp4",
+  "predictions": []
+}

video/video_2026-02-18T12-43-09Z/packhouse1_inline3/predictions/003654.json

@@ -0,0 +1,30 @@
+{
+  "frame_idx": 3654,
+  "image_key": "video/video_2026-02-18T12-43-09Z/packhouse1_inline3/annotated.mp4",
+  "predictions": [
+    {
+      "frame_idx": 3654,
+      "class": "qr code",
+      "bbox": [
+        436.0,
+        384.0,
+        538.0,
+        460.0
+      ],
+      "score": 0.963688850402832,
+      "track_id": "auto-0"
+    },
+    {
+      "frame_idx": 3654,
+      "class": "box",
+      "bbox": [
+        25.0,
+        79.0,
+        1239.0,
+        552.0
+      ],
+      "score": 0.8786520957946777,
+      "track_id": "auto-1"
+    }
+  ]
+}

video/video_2026-02-18T12-43-09Z/packhouse1_inline3/predictions/004191.json

@@ -0,0 +1,5 @@
+{
+  "frame_idx": 4191,
+  "image_key": "video/video_2026-02-18T12-43-09Z/packhouse1_inline3/annotated.mp4",
+  "predictions": []
+}

video/video_2026-02-18T12-43-09Z/packhouse1_inline3/predictions/004216.json

@@ -0,0 +1,5 @@
+{
+  "frame_idx": 4216,
+  "image_key": "video/video_2026-02-18T12-43-09Z/packhouse1_inline3/annotated.mp4",
+  "predictions": []
+}

video/video_2026-02-18T12-43-09Z/packhouse1_inline3/predictions/004353.json

@@ -0,0 +1,5 @@
+{
+  "frame_idx": 4353,
+  "image_key": "video/video_2026-02-18T12-43-09Z/packhouse1_inline3/annotated.mp4",
+  "predictions": []
+}

video/video_2026-02-18T12-43-09Z/packhouse1_inline3/predictions/004646.json

@@ -0,0 +1,5 @@
+{
+  "frame_idx": 4646,
+  "image_key": "video/video_2026-02-18T12-43-09Z/packhouse1_inline3/annotated.mp4",
+  "predictions": []
+}

video/video_2026-02-18T12-43-09Z/packhouse1_inline3/predictions/004703.json

@@ -0,0 +1,42 @@
+{
+  "frame_idx": 4703,
+  "image_key": "video/video_2026-02-18T12-43-09Z/packhouse1_inline3/annotated.mp4",
+  "predictions": [
+    {
+      "frame_idx": 4703,
+      "class": "qr code",
+      "bbox": [
+        1113.0,
+        296.0,
+        1191.0,
+        366.0
+      ],
+      "score": 0.9263305068016052,
+      "track_id": "auto-0"
+    },
+    {
+      "frame_idx": 4703,
+      "class": "box",
+      "bbox": [
+        718.0,
+        0.0,
+        1280.0,
+        458.0
+      ],
+      "score": 0.9188398122787476,
+      "track_id": "auto-1"
+    },
+    {
+      "frame_idx": 4703,
+      "class": "box",
+      "bbox": [
+        0.0,
+        190.0,
+        422.0,
+        598.0
+      ],
+      "score": 0.9017043709754944,
+      "track_id": "auto-2"
+    }
+  ]
+}

video/video_2026-02-18T12-43-09Z/packhouse1_inline3/predictions/004892.json

@@ -0,0 +1,5 @@
+{
+  "frame_idx": 4892,
+  "image_key": "video/video_2026-02-18T12-43-09Z/packhouse1_inline3/annotated.mp4",
+  "predictions": []
+}

video/video_2026-02-18T12-43-09Z/packhouse1_inline3/predictions/004938.json

@@ -0,0 +1,5 @@
+{
+  "frame_idx": 4938,
+  "image_key": "video/video_2026-02-18T12-43-09Z/packhouse1_inline3/annotated.mp4",
+  "predictions": []
+}

video/video_2026-02-18T12-43-09Z/packhouse1_inline3/predictions/005780.json

@@ -0,0 +1,5 @@
+{
+  "frame_idx": 5780,
+  "image_key": "video/video_2026-02-18T12-43-09Z/packhouse1_inline3/annotated.mp4",
+  "predictions": []
+}

video/video_2026-02-18T12-43-09Z/packhouse1_inline3/predictions/005811.json

@@ -0,0 +1,5 @@
+{
+  "frame_idx": 5811,
+  "image_key": "video/video_2026-02-18T12-43-09Z/packhouse1_inline3/annotated.mp4",
+  "predictions": []
+}

video/video_2026-02-18T12-43-09Z/packhouse1_inline3/predictions/006006.json

@@ -0,0 +1,5 @@
+{
+  "frame_idx": 6006,
+  "image_key": "video/video_2026-02-18T12-43-09Z/packhouse1_inline3/annotated.mp4",
+  "predictions": []
+}

video/video_2026-02-18T12-43-09Z/packhouse1_inline3/predictions/006381.json

@@ -0,0 +1,5 @@
+{
+  "frame_idx": 6381,
+  "image_key": "video/video_2026-02-18T12-43-09Z/packhouse1_inline3/annotated.mp4",
+  "predictions": []
+}

video/video_2026-02-18T12-43-09Z/packhouse1_inline3/predictions/006456.json

@@ -0,0 +1,5 @@
+{
+  "frame_idx": 6456,
+  "image_key": "video/video_2026-02-18T12-43-09Z/packhouse1_inline3/annotated.mp4",
+  "predictions": []
+}

video/video_2026-02-18T12-43-09Z/packhouse1_inline3/predictions/006694.json

@@ -0,0 +1,5 @@
+{
+  "frame_idx": 6694,
+  "image_key": "video/video_2026-02-18T12-43-09Z/packhouse1_inline3/annotated.mp4",
+  "predictions": []
+}

video/video_2026-02-18T12-43-09Z/packhouse1_inline3/predictions/006905.json

@@ -0,0 +1,5 @@
+{
+  "frame_idx": 6905,
+  "image_key": "video/video_2026-02-18T12-43-09Z/packhouse1_inline3/annotated.mp4",
+  "predictions": []
+}

video/video_2026-02-18T12-43-09Z/packhouse1_inline3/predictions/007617.json

@@ -0,0 +1,30 @@
+{
+  "frame_idx": 7617,
+  "image_key": "video/video_2026-02-18T12-43-09Z/packhouse1_inline3/annotated.mp4",
+  "predictions": [
+    {
+      "frame_idx": 7617,
+      "class": "qr code",
+      "bbox": [
+        471.0,
+        359.0,
+        573.0,
+        433.0
+      ],
+      "score": 0.9071722030639648,
+      "track_id": "auto-0"
+    },
+    {
+      "frame_idx": 7617,
+      "class": "box",
+      "bbox": [
+        18.0,
+        79.0,
+        1280.0,
+        551.0
+      ],
+      "score": 0.7447725534439087,
+      "track_id": "auto-1"
+    }
+  ]
+}

video/video_2026-02-18T12-43-09Z/packhouse1_inline3/predictions/007986.json

@@ -0,0 +1,30 @@
+{
+  "frame_idx": 7986,
+  "image_key": "video/video_2026-02-18T12-43-09Z/packhouse1_inline3/annotated.mp4",
+  "predictions": [
+    {
+      "frame_idx": 7986,
+      "class": "box",
+      "bbox": [
+        296.0,
+        169.0,
+        1280.0,
+        618.0
+      ],
+      "score": 0.8656734824180603,
+      "track_id": "auto-0"
+    },
+    {
+      "frame_idx": 7986,
+      "class": "box",
+      "bbox": [
+        0.0,
+        270.0,
+        84.0,
+        451.0
+      ],
+      "score": 0.515254557132721,
+      "track_id": "auto-1"
+    }
+  ]
+}

video/video_2026-02-18T12-43-09Z/packhouse1_inline3/predictions/008018.json

@@ -0,0 +1,18 @@
+{
+  "frame_idx": 8018,
+  "image_key": "video/video_2026-02-18T12-43-09Z/packhouse1_inline3/annotated.mp4",
+  "predictions": [
+    {
+      "frame_idx": 8018,
+      "class": "box",
+      "bbox": [
+        868.0,
+        100.0,
+        1280.0,
+        493.0
+      ],
+      "score": 0.9315822720527649,
+      "track_id": "auto-0"
+    }
+  ]
+}

video/video_2026-02-18T12-43-09Z/packhouse1_inline3/predictions/008448.json

@@ -0,0 +1,5 @@
+{
+  "frame_idx": 8448,
+  "image_key": "video/video_2026-02-18T12-43-09Z/packhouse1_inline3/annotated.mp4",
+  "predictions": []
+}

video/video_2026-02-18T12-43-09Z/packhouse1_inline3/predictions/009074.json

@@ -0,0 +1,5 @@
+{
+  "frame_idx": 9074,
+  "image_key": "video/video_2026-02-18T12-43-09Z/packhouse1_inline3/annotated.mp4",
+  "predictions": []
+}

video/video_2026-02-18T12-43-09Z/packhouse1_inline3/predictions/009131.json

@@ -0,0 +1,5 @@
+{
+  "frame_idx": 9131,
+  "image_key": "video/video_2026-02-18T12-43-09Z/packhouse1_inline3/annotated.mp4",
+  "predictions": []
+}

video/video_2026-02-18T12-43-09Z/packhouse1_inline3/predictions/009259.json

@@ -0,0 +1,5 @@
+{
+  "frame_idx": 9259,
+  "image_key": "video/video_2026-02-18T12-43-09Z/packhouse1_inline3/annotated.mp4",
+  "predictions": []
+}

video/video_2026-02-18T12-43-09Z/packhouse1_inline3/predictions/009424.json

@@ -0,0 +1,18 @@
+{
+  "frame_idx": 9424,
+  "image_key": "video/video_2026-02-18T12-43-09Z/packhouse1_inline3/annotated.mp4",
+  "predictions": [
+    {
+      "frame_idx": 9424,
+      "class": "box",
+      "bbox": [
+        971.0,
+        0.0,
+        1280.0,
+        449.0
+      ],
+      "score": 0.8857800960540771,
+      "track_id": "auto-0"
+    }
+  ]
+}

video/video_2026-02-18T12-43-09Z/packhouse1_inline3/predictions/009561.json

@@ -0,0 +1,5 @@
+{
+  "frame_idx": 9561,
+  "image_key": "video/video_2026-02-18T12-43-09Z/packhouse1_inline3/annotated.mp4",
+  "predictions": []
+}

video/video_2026-02-18T12-43-09Z/packhouse1_inline3/predictions/009609.json

@@ -0,0 +1,30 @@
+{
+  "frame_idx": 9609,
+  "image_key": "video/video_2026-02-18T12-43-09Z/packhouse1_inline3/annotated.mp4",
+  "predictions": [
+    {
+      "frame_idx": 9609,
+      "class": "box",
+      "bbox": [
+        0.0,
+        0.0,
+        509.0,
+        454.0
+      ],
+      "score": 0.8452643156051636,
+      "track_id": "auto-0"
+    },
+    {
+      "frame_idx": 9609,
+      "class": "box",
+      "bbox": [
+        0.0,
+        156.0,
+        1240.0,
+        623.0
+      ],
+      "score": 0.7703803777694702,
+      "track_id": "auto-1"
+    }
+  ]
+}

video/video_2026-02-18T12-43-09Z/packhouse1_inline3/predictions/010078.json

@@ -0,0 +1,5 @@
+{
+  "frame_idx": 10078,
+  "image_key": "video/video_2026-02-18T12-43-09Z/packhouse1_inline3/annotated.mp4",
+  "predictions": []
+}

video/video_2026-02-18T12-43-09Z/packhouse1_inline3/predictions/010255.json

@@ -0,0 +1,5 @@
+{
+  "frame_idx": 10255,
+  "image_key": "video/video_2026-02-18T12-43-09Z/packhouse1_inline3/annotated.mp4",
+  "predictions": []
+}

video/video_2026-02-18T12-43-09Z/packhouse1_inline3/predictions/010310.json

@@ -0,0 +1,5 @@
+{
+  "frame_idx": 10310,
+  "image_key": "video/video_2026-02-18T12-43-09Z/packhouse1_inline3/annotated.mp4",
+  "predictions": []
+}

video/video_2026-02-18T12-43-09Z/packhouse1_inline3/predictions/010428.json

@@ -0,0 +1,18 @@
+{
+  "frame_idx": 10428,
+  "image_key": "video/video_2026-02-18T12-43-09Z/packhouse1_inline3/annotated.mp4",
+  "predictions": [
+    {
+      "frame_idx": 10428,
+      "class": "box",
+      "bbox": [
+        0.0,
+        277.0,
+        67.0,
+        446.0
+      ],
+      "score": 0.4784950613975525,
+      "track_id": "auto-0"
+    }
+  ]
+}

video/video_2026-02-18T12-43-09Z/packhouse1_inline3/predictions/010582.json

@@ -0,0 +1,5 @@
+{
+  "frame_idx": 10582,
+  "image_key": "video/video_2026-02-18T12-43-09Z/packhouse1_inline3/annotated.mp4",
+  "predictions": []
+}

video/video_2026-02-18T12-43-09Z/packhouse1_inline3/predictions/010605.json

@@ -0,0 +1,5 @@
+{
+  "frame_idx": 10605,
+  "image_key": "video/video_2026-02-18T12-43-09Z/packhouse1_inline3/annotated.mp4",
+  "predictions": []
+}

video/video_2026-02-18T12-43-09Z/packhouse1_inline3/predictions/011239.json

@@ -0,0 +1,5 @@
+{
+  "frame_idx": 11239,
+  "image_key": "video/video_2026-02-18T12-43-09Z/packhouse1_inline3/annotated.mp4",
+  "predictions": []
+}

video/video_2026-02-18T12-43-09Z/packhouse1_inline3/predictions/011393.json

@@ -0,0 +1,5 @@
+{
+  "frame_idx": 11393,
+  "image_key": "video/video_2026-02-18T12-43-09Z/packhouse1_inline3/annotated.mp4",
+  "predictions": []
+}