pytensor 2.36.0__tar.gz → 2.36.1__tar.gz

{pytensor-2.36.0/pytensor.egg-info → pytensor-2.36.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytensor
-Version: 2.36.0
+Version: 2.36.1
 Summary: Optimizing compiler for evaluating mathematical expressions on CPUs and GPUs.
 Author-email: pymc-devs <pymc.devs@gmail.com>
 License-Expression: BSD-3-Clause

{pytensor-2.36.0 → pytensor-2.36.1}/pytensor/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2025-12-15T22:58:11+0100",
+ "date": "2025-12-21T14:56:52+0000",
  "dirty": false,
  "error": null,
- "full-revisionid": "6319fac84ebc71ad079c5986c6c302a52e254198",
- "version": "2.36.0"
+ "full-revisionid": "409a4b2a02e64acc0ca12cd0e046e99fd6f535b9",
+ "version": "2.36.1"
 }
 '''  # END VERSION_JSON
 

{pytensor-2.36.0 → pytensor-2.36.1}/pytensor/link/numba/cache.py

@@ -11,7 +11,7 @@ from pytensor.configdefaults import config
 
 
 NUMBA_CACHE_PATH = config.base_compiledir / "numba"
-NUMBA_CACHE_PATH.mkdir(exist_ok=True)
+NUMBA_CACHE_PATH.mkdir(parents=True, exist_ok=True)
 CACHED_SRC_FUNCTIONS: WeakKeyDictionary[Callable, str] = WeakKeyDictionary()
 
 

{pytensor-2.36.0 → pytensor-2.36.1}/pytensor/link/pytorch/dispatch/scalar.py

@@ -5,6 +5,7 @@ import torch
 from pytensor.link.pytorch.dispatch.basic import pytorch_funcify
 from pytensor.scalar.basic import (
     Cast,
+    Clip,
     Invert,
     ScalarOp,
 )
@@ -71,6 +72,14 @@ def pytorch_funcify_Softplus(op, node, **kwargs):
     return torch.nn.Softplus()
 
 
+@pytorch_funcify.register(Clip)
+def pytorch_funcify_Clip(op, node, **kwargs):
+    def clip(x, min_val, max_val):
+        return torch.where(x < min_val, min_val, torch.where(x > max_val, max_val, x))
+
+    return clip
+
+
 @pytorch_funcify.register(ScalarLoop)
 def pytorch_funicify_ScalarLoop(op, node, **kwargs):
     update = pytorch_funcify(op.fgraph, **kwargs)

{pytensor-2.36.0 → pytensor-2.36.1}/pytensor/scan/basic.py

@@ -1,5 +1,6 @@
 import typing
 import warnings
+from functools import reduce
 from itertools import chain
 
 import numpy as np
@@ -16,7 +17,6 @@ from pytensor.graph.type import HasShape
 from pytensor.graph.utils import MissingInputError, TestValueError
 from pytensor.scan.op import Scan, ScanInfo
 from pytensor.scan.utils import expand_empty, safe_new, until
-from pytensor.tensor.basic import get_underlying_scalar_constant_value
 from pytensor.tensor.exceptions import NotScalarConstantError
 from pytensor.tensor.math import minimum
 from pytensor.tensor.shape import shape_padleft
@@ -143,31 +143,6 @@ def get_updates_and_outputs(ls):
         raise ValueError(error_msg)
 
 
-def isNaN_or_Inf_or_None(x):
-    isNone = x is None
-    try:
-        isNaN = np.isnan(x)
-        isInf = np.isinf(x)
-        isStr = isinstance(x, str)
-    except Exception:
-        isNaN = False
-        isInf = False
-        isStr = False
-    if not isNaN and not isInf:
-        try:
-            val = get_underlying_scalar_constant_value(x)
-            isInf = np.isinf(val)
-            isNaN = np.isnan(val)
-        except Exception:
-            isNaN = False
-            isInf = False
-    if isinstance(x, Constant) and isinstance(x.data, str):
-        isStr = True
-    else:
-        isStr = False
-    return isNone or isNaN or isInf or isStr
-
-
 def _manage_output_api_change(outputs, updates, return_updates):
     if return_updates:
         warnings.warn(
@@ -505,7 +480,7 @@ def scan(
 
     # This helper eagerly skips the Scan if n_steps is known to be 1
     single_step_requested = False
-    if isinstance(n_steps, float | int):
+    if isinstance(n_steps, int | float):
         single_step_requested = n_steps == 1
     else:
         try:
@@ -676,33 +651,20 @@ def scan(
                 if nw_name is not None:
                     nw_seq.name = nw_name
 
-    # Since we've added all sequences now we need to level them up based on
-    # n_steps or their different shapes
-    lengths_vec = [seq.shape[0] for seq in scan_seqs]
-
-    if not isNaN_or_Inf_or_None(n_steps):
-        # ^ N_steps should also be considered
-        lengths_vec.append(pt.as_tensor(n_steps))
-
-    if len(lengths_vec) == 0:
-        # ^ No information about the number of steps
-        raise ValueError(
-            "No information about the number of steps "
-            "provided. Either provide a value for "
-            "n_steps argument of scan or provide an input "
-            "sequence"
-        )
-
-    # If the user has provided the number of steps, do that regardless ( and
-    # raise an error if the sequences are not long enough )
-    if isNaN_or_Inf_or_None(n_steps):
-        actual_n_steps = lengths_vec[0]
-        for contestant in lengths_vec[1:]:
-            actual_n_steps = minimum(actual_n_steps, contestant)
+    if n_steps is None:
+        if not scan_seqs:
+            raise ValueError(
+                "No information about the number of steps provided. "
+                "Either provide a value for n_steps argument of scan or provide an input sequence."
+            )
+        actual_n_steps = reduce(minimum, [seq.shape[0] for seq in scan_seqs])
     else:
-        actual_n_steps = pt.as_tensor(n_steps)
+        actual_n_steps = pt.as_tensor(n_steps, dtype="int64", ndim=0)
 
+    # Since we've added all sequences now we need to level them off based on
+    # n_steps or their different shapes
     scan_seqs = [seq[:actual_n_steps] for seq in scan_seqs]
+
     # Conventions :
     #   mit_mot = multiple input taps, multiple output taps ( only provided
     #             by the gradient function )
@@ -899,10 +861,8 @@ def scan(
         raw_inner_outputs = fn(*args)
 
     condition, outputs, updates = get_updates_and_outputs(raw_inner_outputs)
-    if condition is not None:
-        as_while = True
-    else:
-        as_while = False
+    as_while = condition is not None
+
     ##
     # Step 3. Check if we actually need scan and remove it if we don't
     ##
@@ -934,7 +894,7 @@ def scan(
 
     # extract still missing inputs (there still might be so) and add them
     # as non sequences at the end of our args
-    if condition is not None:
+    if as_while:
         outputs.append(condition)
     fake_nonseqs = [x.type() for x in non_seqs]
     fake_outputs = clone_replace(
@@ -1252,8 +1212,8 @@ def scan(
     rightOrder = (
         mit_sot_rightOrder
         + sit_sot_rightOrder
-        + untraced_sit_sot_rightOrder
         + nit_sot_rightOrder
+        + untraced_sit_sot_rightOrder
     )
     scan_out_list = [None] * len(rightOrder)
     for idx, pos in enumerate(rightOrder):

{pytensor-2.36.0 → pytensor-2.36.1}/pytensor/sparse/math.py

@@ -41,7 +41,7 @@ def structured_elemwise(tensor_op):
 
 
 @structured_elemwise(ptm.abs)
-def structured_abs(x):
+def abs(x):
     """
     Compute abs(x) for all non-zero elements of x.
     """
@@ -61,13 +61,6 @@ def structured_exp(x):
     """
 
 
-@structured_elemwise(ptm.exp2)
-def structured_exp2(x):
-    """
-    Compute exp2(x) for all non-zero elements of x.
-    """
-
-
 @structured_elemwise(ptm.log)
 def structured_log(x):
     """
@@ -75,20 +68,6 @@ def structured_log(x):
     """
 
 
-@structured_elemwise(ptm.log2)
-def structured_log2(x):
-    """
-    Compute log2(x) for all non-zero elements of x.
-    """
-
-
-@structured_elemwise(ptm.log10)
-def structured_log10(x):
-    """
-    Compute log10(x) for all non-zero elements of x.
-    """
-
-
 @structured_elemwise(ptm.pow)
 def structured_pow(x, y):
     """
@@ -118,161 +97,133 @@ def structured_add(x, y):
 
 
 @structured_elemwise(ptm.sin)
-def structured_sin(x):
+def sin(x):
     """
     Compute sin(x) for all non-zero elements of x.
     """
 
 
 @structured_elemwise(ptm.sinh)
-def structured_sinh(x):
+def sinh(x):
     """
     Compute sinh(x) for all non-zero elements of x.
     """
 
 
 @structured_elemwise(ptm.arcsin)
-def structured_arcsin(x):
+def arcsin(x):
     """
     Compute arcsin(x) for all non-zero elements of x.
     """
 
 
 @structured_elemwise(ptm.arcsinh)
-def structured_arcsinh(x):
+def arcsinh(x):
     """
     Compute arcsinh(x) for all non-zero elements of x.
     """
 
 
-@structured_elemwise(ptm.cos)
-def structured_cos(x):
-    """
-    Compute cos(x) for all non-zero elements of x.
-    """
-
-
-@structured_elemwise(ptm.cosh)
-def structured_cosh(x):
-    """
-    Compute cosh(x) for all non-zero elements of x.
-    """
-
-
-@structured_elemwise(ptm.arccos)
-def structured_arccos(x):
-    """
-    Compute arccos(x) for all non-zero elements of x.
-    """
-
-
-@structured_elemwise(ptm.arccosh)
-def structured_arccosh(x):
-    """
-    Compute arccosh(x) for all non-zero elements of x.
-    """
-
-
 @structured_elemwise(ptm.tan)
-def structured_tan(x):
+def tan(x):
     """
     Compute tan(x) for all non-zero elements of x.
     """
 
 
 @structured_elemwise(ptm.tanh)
-def structured_tanh(x):
+def tanh(x):
     """
     Compute tanh(x) for all non-zero elements of x.
     """
 
 
 @structured_elemwise(ptm.arctan)
-def structured_arctan(x):
+def arctan(x):
     """
     Compute arctan(x) for all non-zero elements of x.
     """
 
 
 @structured_elemwise(ptm.arctanh)
-def structured_arctanh(x):
+def arctanh(x):
     """
     Compute arctanh(x) for all non-zero elements of x.
     """
 
 
 @structured_elemwise(ptm.round_half_to_even)
-def structured_rint(x):
+def rint(x):
     """
     Compute round_half_to_even(x) for all non-zero elements of x.
     """
 
 
 @structured_elemwise(ptm.sign)
-def structured_sign(x):
+def sign(x):
     """
     Compute sign(x) for all non-zero elements of x.
     """
 
 
 @structured_elemwise(ptm.ceil)
-def structured_ceil(x):
+def ceil(x):
     """
     Compute ceil(x) for all non-zero elements of x.
     """
 
 
 @structured_elemwise(ptm.floor)
-def structured_floor(x):
+def floor(x):
     """
     Compute floor(x) for all non-zero elements of x.
     """
 
 
 @structured_elemwise(ptm.log1p)
-def structured_log1p(x):
+def log1p(x):
     """
     Compute log(1 + x) for all non-zero elements of x.
     """
 
 
 @structured_elemwise(ptm.expm1)
-def structured_expm1(x):
+def expm1(x):
     """
     Compute exp(x) - 1 for all non-zero elements of x.
     """
 
 
 @structured_elemwise(ptm.deg2rad)
-def structured_deg2rad(x):
+def deg2rad(x):
     """
     Convert degrees to radians for all non-zero elements of x.
     """
 
 
 @structured_elemwise(ptm.rad2deg)
-def structured_rad2deg(x):
+def rad2deg(x):
     """
     Convert radians to degrees for all non-zero elements of x.
     """
 
 
 @structured_elemwise(ptm.trunc)
-def structured_trunc(x):
+def trunc(x):
     """
     Truncate the decimal part of x for all non-zero elements of x.
     """
 
 
 @structured_elemwise(ptm.sqr)
-def structured_sqr(x):
+def sqr(x):
     """
     Compute sqr(x) for all non-zero elements of x.
     """
 
 
 @structured_elemwise(ptm.sqrt)
-def structured_sqrt(x):
+def sqrt(x):
     """
     Compute sqrt(x) for all non-zero elements of x.
     """
@@ -292,7 +243,7 @@ def conjugate(x):
     return _conj(_x)
 
 
-structured_conjugate = conjugate
+structured_conjugate = conj = conjugate
 
 
 class SpSum(Op):

{pytensor-2.36.0 → pytensor-2.36.1}/pytensor/tensor/__init__.py

@@ -133,6 +133,11 @@ from pytensor.tensor.extra_ops import *
 from pytensor.tensor.interpolate import interp, interpolate1d
 from pytensor.tensor.math import *
 from pytensor.tensor.pad import pad
+
+
+# isort: off
+# reshape needs to be imported before shape.reshape, otherwise the tensor.reshape imports fail
+from pytensor.tensor.reshape import *
 from pytensor.tensor.shape import (
     reshape,
     shape,
@@ -143,6 +148,8 @@ from pytensor.tensor.shape import (
     specify_shape,
 )
 
+# isort: on
+
 # We import as `_shared` instead of `shared` to avoid confusion between
 # `pytensor.shared` and `tensor._shared`.
 from pytensor.tensor.sort import argsort, sort