pytensor 3.1.1__tar.gz → 3.1.3__tar.gz

{pytensor-3.1.1/pytensor.egg-info → pytensor-3.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytensor
-Version: 3.1.1
+Version: 3.1.3
 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-3.1.1 → pytensor-3.1.3}/doc/internal/how_to_release.rst

@@ -13,10 +13,6 @@ Update the version number
 
 Update the year in the ``PyTensor/LICENSE.txt`` file too, if necessary.
 
-Update the code and the documentation for the pytensor flags
-``warn__ignore_bug_before`` to accept the new version. You must modify the
-file ``pytensor/configdefaults.py`` and ``doc/library/config.txt``.
-
 Tag the release
 ===============
 

{pytensor-3.1.1 → pytensor-3.1.3}/doc/library/config.rst

@@ -405,31 +405,6 @@ import ``pytensor`` and print the config variable, as in:
     raise the exception (i.e. ``'raise'``).
 
 
-.. attribute:: config.warn__ignore_bug_before
-
-    String value: ``'None'``, ``'all'``, ``'0.3'``, ``'0.4'``, ``'0.4.1'``,
-    ``'0.5'``, ``'0.6'``, ``'0.7'``, ``'0.8'``, ``'0.8.1'``, ``'0.8.2'``,
-    ``'0.9'``, ``'0.10'``, ``'1.0'``, ``'1.0.1'``, ``'1.0.2'``, ``'1.0.3'``,
-    ``'1.0.4'``,``'1.0.5'``
-
-    Default: ``'0.9'``
-
-    When we an PyTensor bug that generated a bad result is fixed, we also make
-    PyTensor raise a warning when it encounters the same circumstances again. This
-    helps users determine whether or not said bug has affected past runs, since
-    one only needs to perform the same runs again with the new version, and one
-    does not have to understand the PyTensor internals that triggered the bug.
-
-    This flag lets users ignore warnings about old bugs that were
-    fixed before their first checkout of PyTensor.
-    You can set its value to the first version of PyTensor
-    that you used (probably 0.3 or higher)
-
-    ``'None'`` means that all warnings will be displayed.
-    ``'all'`` means all warnings will be ignored.
-
-    This flag's value cannot be modified during program execution.
-
 .. attribute:: base_compiledir
 
     Default: On Windows: ``$LOCALAPPDATA\\PyTensor`` if ``$LOCALAPPDATA`` is defined,
@@ -734,11 +709,3 @@ import ``pytensor`` and print the config variable, as in:
     The number of traceback stack levels to keep for variables during PyTensor
     compilation. When this value is greater than zero, it will make PyTensor keep
     internal stack traces.
-
-.. attribute:: config.metaopt__verbose
-
-    Int value, default: 0
-
-    The verbosity level of the meta-rewriter: ``0`` for silent, ``1`` to only
-    warn when PyTensor cannot meta-rewrite an :class:`Op`, ``2`` for full output (e.g.
-    timings and the rewrites selected).

{pytensor-3.1.1 → pytensor-3.1.3}/pytensor/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2026-07-03T07:15:26+0200",
+ "date": "2026-07-10T22:43:47+0200",
  "dirty": false,
  "error": null,
- "full-revisionid": "6b70d2cf2126abb036bbbe0f355e21957936eedf",
- "version": "3.1.1"
+ "full-revisionid": "4c7f21181b616d2e05310a518c87cc661ba1b97e",
+ "version": "3.1.3"
 }
 '''  # END VERSION_JSON
 

{pytensor-3.1.1 → pytensor-3.1.3}/pytensor/compile/builders.py

@@ -8,8 +8,7 @@ from collections.abc import Callable, Sequence
 from copy import copy
 from functools import partial
 
-from pytensor.compile.io import In, Out
-from pytensor.compile.mode import get_mode
+from pytensor.compile.inner_function import HasInnerFunction
 from pytensor.compile.sharedvalue import SharedVariable
 from pytensor.gradient import DisconnectedType, disconnected_type, grad, pushforward
 from pytensor.graph.basic import (
@@ -20,7 +19,7 @@ from pytensor.graph.basic import (
 )
 from pytensor.graph.fg import FrozenFunctionGraph, FunctionGraph
 from pytensor.graph.null_type import NullType
-from pytensor.graph.op import HasInnerGraph, Op, io_connection_pattern
+from pytensor.graph.op import Op, io_connection_pattern
 from pytensor.graph.replace import clone_replace
 from pytensor.graph.traversal import graph_inputs
 from pytensor.graph.utils import MissingInputError
@@ -114,7 +113,7 @@ def construct_nominal_fgraph(
     return fgraph
 
 
-class OpFromGraph(Op, HasInnerGraph):
+class OpFromGraph(HasInnerFunction, Op):
     r"""Create an Op from inputs and outputs lists of variables.
 
     The signature is similar to :func:`pytensor.function` and the resulting Op's perform will do
@@ -840,50 +839,6 @@ class OpFromGraph(Op, HasInnerGraph):
 
         return ret
 
-    @property
-    def fn(self):
-        """Lazily compile the inner function graph."""
-        if getattr(self, "_fn", None) is not None:
-            return self._fn
-
-        # ``op.fgraph`` is already backend-optimized (inplace included): the
-        # ``ofg_inner_graph`` rewrite ran the backend optimizer on it during the
-        # outer compile. So we only need to link it. The linker forces
-        # ``minimum_compile`` back in via its ``required_rewrites``, and (for an
-        # inner graph) ``minimum_compile`` *is* that inner-graph rewrite -- so we
-        # exclude ``compile_inner_graph`` to stop it re-baking an already-baked
-        # graph. ``prepare_fgraph`` still inserts the boundary deepcopies; passing
-        # ``fgraph=`` avoids a re-clone. Unused inputs (e.g. rng, size) and
-        # internal-only inplace ops are expected and tolerated.
-        mode = (
-            get_mode(None)
-            .clone(optimizer="minimum_compile")
-            .excluding("compile_inner_graph")
-        )
-        unfrozen_fgraph = self.fgraph.unfreeze()
-        self._fn = mode.function_maker(
-            [In(inp, borrow=True) for inp in unfrozen_fgraph.inputs],
-            [Out(out, borrow=True) for out in unfrozen_fgraph.outputs],
-            mode,
-            fgraph=unfrozen_fgraph,
-            accept_inplace=True,
-            on_unused_input="ignore",
-        ).create()
-        self._fn.trust_input = True
-
-        return self._fn
-
-    @property
-    def inner_inputs(self):
-        # A list (not the frozen tuple) so callers that concatenate inner
-        # inputs/outputs keep list semantics. Read-only views of the immutable
-        # graph; manipulating them requires a fresh/unfrozen graph.
-        return list(self.fgraph.inputs)
-
-    @property
-    def inner_outputs(self):
-        return list(self.fgraph.outputs)
-
     def clone(self):
         # The inner graph is immutable (a frozen ``FunctionGraph``), so there is
         # nothing to deep-clone -- mirror ``Composite.clone``.

{pytensor-3.1.1 → pytensor-3.1.3}/pytensor/compile/debug/profiling.py

@@ -9,7 +9,6 @@ ProfileStats object for runtime and memory profiling.
 #
 
 import atexit
-import copy
 import logging
 import operator
 import sys
@@ -54,8 +53,6 @@ _atexit_registered: bool = False
 def _atexit_print_fn():
     """Print `ProfileStat` objects in `_atexit_print_list` to `_atexit_print_file`."""
     if config.profile:
-        to_sum = []
-
         if config.profiling__destination == "stderr":
             destination_file = "<stderr>"
         elif config.profiling__destination == "stdout":
@@ -78,64 +75,9 @@ def _atexit_print_fn():
                         n_ops_to_print=config.profiling__n_ops,
                         n_apply_to_print=config.profiling__n_apply,
                     )
-
-                    if ps.show_sum:
-                        to_sum.append(ps)
                 else:
                     # TODO print the name if there is one!
                     print("Skipping empty Profile")  # noqa: T201
-            if len(to_sum) > 1:
-                # Make a global profile
-                cum = copy.copy(to_sum[0])
-                msg = f"Sum of all({len(to_sum)}) printed profiles at exit."
-                cum.message = msg
-                for ps in to_sum[1:]:
-                    for attr in [
-                        "compile_time",
-                        "fct_call_time",
-                        "fct_callcount",
-                        "vm_call_time",
-                        "rewriter_time",
-                        "linker_time",
-                        "validate_time",
-                        "import_time",
-                        "linker_node_make_thunks",
-                    ]:
-                        setattr(cum, attr, getattr(cum, attr) + getattr(ps, attr))
-
-                    # merge dictionary
-                    for attr in [
-                        "apply_time",
-                        "apply_callcount",
-                        "apply_cimpl",
-                        "variable_shape",
-                        "variable_strides",
-                        "variable_offset",
-                        "linker_make_thunk_time",
-                    ]:
-                        cum_attr = getattr(cum, attr)
-                        for key, val in getattr(ps, attr.items()):
-                            assert key not in cum_attr, (key, cum_attr)
-                            cum_attr[key] = val
-
-                    if cum.rewriter_profile and ps.rewriter_profile:
-                        try:
-                            merge = cum.rewriter_profile[0].merge_profile(
-                                cum.rewriter_profile[1], ps.rewriter_profile[1]
-                            )
-                            assert len(merge) == len(cum.rewriter_profile[1])
-                            cum.rewriter_profile = (cum.rewriter_profile[0], merge)
-                        except Exception as e:
-                            print(e)  # noqa: T201
-                            cum.rewriter_profile = None
-                    else:
-                        cum.rewriter_profile = None
-
-                cum.summary(
-                    file=f,
-                    n_ops_to_print=config.profiling__n_ops,
-                    n_apply_to_print=config.profiling__n_apply,
-                )
 
     if config.print_global_stats:
         print_global_stats()
@@ -159,7 +101,7 @@ def print_global_stats():
         destination_file = config.profiling__destination
 
     with extended_open(destination_file, mode="w") as f:
-        print("=" * 50, file=destination_file)
+        print("=" * 50, file=f)
         print(
             (
                 "Global stats: ",

pytensor-3.1.3/pytensor/compile/inner_function.py

@@ -0,0 +1,84 @@
+"""Shared machinery for `Op`\\s that execute a lazily linked inner function."""
+
+from typing import TYPE_CHECKING
+
+from pytensor.compile.io import In, Out
+from pytensor.compile.mode import Mode
+from pytensor.graph.fg import FrozenFunctionGraph, FunctionGraph
+from pytensor.graph.op import HasInnerGraph
+from pytensor.graph.rewriting.basic import SequentialGraphRewriter
+from pytensor.link.basic import Linker
+
+
+if TYPE_CHECKING:
+    from pytensor.compile.function.types import Function
+
+
+def link_only_mode(linker: str | Linker) -> Mode:
+    """A `Mode` that links a graph without rewriting it at all.
+
+    The bare rewriter also bypasses the ``minimum_compile`` pass the linker
+    would otherwise force onto a database query.
+    """
+    return Mode(linker, SequentialGraphRewriter())
+
+
+class HasInnerFunction(HasInnerGraph):
+    """`HasInnerGraph` op whose ``perform`` runs a lazily linked inner function.
+
+    The frozen inner graph was already baked for the backend by the
+    ``compile_inner_graph`` rewrites during the outer compile, so linking it
+    needs no further rewrites (see `link_only_mode`).
+
+    The linker never comes from the config default mode: ``perform`` only runs
+    under the py/c backend family -- JIT backends (numba/jax/...) funcify
+    ``op.fgraph`` directly and never call ``perform`` -- so a JIT default must
+    not win, and the JIT inner-graph rewrites were never applied to this graph.
+    """
+
+    _fn = None
+    fgraph: FrozenFunctionGraph
+
+    def link_mode(self, impl: str | None) -> Mode:
+        """The `Mode` to link the inner function with, given a thunk ``impl``."""
+        return link_only_mode("cvm" if impl == "c" else "vm")
+
+    def link_fgraph(self, fgraph: FunctionGraph, mode: Mode) -> "Function":
+        """Link an already-baked inner ``fgraph`` under ``mode``, no rewrites."""
+        fn = mode.function_maker(
+            [In(inp) for inp in fgraph.inputs],
+            [Out(out) for out in fgraph.outputs],
+            mode,
+            fgraph=fgraph,
+            accept_inplace=True,
+            on_unused_input="ignore",
+        ).create()
+        fn.trust_input = True
+        return fn
+
+    def compile_fn(self, mode: Mode) -> "Function":
+        """Build the inner function under ``mode`` (override to massage the graph)."""
+        return self.link_fgraph(self.fgraph.unfreeze(), mode)
+
+    @property
+    def fn(self) -> "Function":
+        if self._fn is None:
+            self._fn = self.compile_fn(self.link_mode(None))
+        return self._fn
+
+    def make_thunk(self, node, storage_map, compute_map, no_recycling, impl=None):
+        if self._fn is None:
+            self._fn = self.compile_fn(self.link_mode(impl))
+        return super().make_thunk(
+            node, storage_map, compute_map, no_recycling, impl=impl
+        )
+
+    @property
+    def inner_inputs(self):
+        # Read-only views of the immutable inner graph, as lists so callers
+        # that concatenate inputs/outputs keep list semantics.
+        return list(self.fgraph.inputs)
+
+    @property
+    def inner_outputs(self):
+        return list(self.fgraph.outputs)

{pytensor-3.1.1 → pytensor-3.1.3}/pytensor/compile/maker.py

@@ -469,14 +469,7 @@ class FunctionMaker:
                 mode=mode,
                 traceback__limit=config.traceback__compile_limit,
             ):
-                # Expose the compile mode so inner-graph rewrites can recover
-                # the active linker's required/incompatible rewrites reliably
-                # (``config.mode`` is unreliable across nested compilations).
-                fgraph._compile_mode = mode
-                try:
-                    rewriter_profile = rewriter(fgraph)
-                finally:
-                    del fgraph._compile_mode
+                rewriter_profile = rewriter(fgraph)
 
                 end_rewriter = time.perf_counter()
                 rewrite_time = end_rewriter - start_rewriter

{pytensor-3.1.1 → pytensor-3.1.3}/pytensor/compile/mode.py

@@ -4,6 +4,7 @@ WRITEME
 """
 
 import logging
+import sys
 import warnings
 from typing import Any
 
@@ -279,6 +280,53 @@ optdb.register("CheckStackTrace", CheckStackTraceRewriter(), *_tags, position=-1
 del _tags
 
 
+class _ActiveModeGraphRewriter(GraphRewriter):
+    """Wrap a mode's optimizer so applying it records the active compile mode.
+
+    Exposes the compile mode as ``fgraph._compile_mode`` (see ``get_active_mode``)
+    so rewrites can make decisions based on the compile target (fusion split rules,
+    inner graph specialization, ...). Stamps the mode when the fgraph does not already carry one, and
+    restores the previous state after.
+    """
+
+    def __init__(self, rewriter: GraphRewriter, mode: "Mode"):
+        self._rewriter = rewriter
+        self._mode = mode
+
+    def add_requirements(self, fgraph):
+        return self._rewriter.add_requirements(fgraph)
+
+    def apply(self, fgraph, *args, **kwargs):
+        # Only stamp when unset, so a mode already established by an outer
+        # optimizer run (the outermost compilation, or a nested inner-graph
+        # rewrite) wins.
+        stamped = getattr(fgraph, "_compile_mode", None) is None
+        if stamped:
+            fgraph._compile_mode = self._mode
+        try:
+            return self._rewriter.apply(fgraph, *args, **kwargs)
+        finally:
+            if stamped:
+                del fgraph._compile_mode
+
+    def print_summary(self, stream=sys.stdout, level=0, depth=-1):
+        return self._rewriter.print_summary(stream=stream, level=level, depth=depth)
+
+    def print_profile(self, stream, prof, level=0):
+        # ``GraphRewriter.print_profile`` is a classmethod that raises unless
+        # overridden, so delegate to the wrapped rewriter's implementation.
+        return self._rewriter.print_profile(stream, prof, level=level)
+
+    def __getattr__(self, name):
+        # Delegate everything else (profiling helpers, query metadata, ...) to the
+        # wrapped rewriter. ``__getattr__`` only fires for names not found normally,
+        # so the overrides above take precedence. Guard ``_rewriter`` itself to avoid
+        # infinite recursion before ``__init__`` has run.
+        if name == "_rewriter":
+            raise AttributeError(name)
+        return getattr(self._rewriter, name)
+
+
 class Mode:
     """A class that specifies the rewrites/optimizations used during function compilation.
 
@@ -305,7 +353,7 @@ class Mode:
     def __init__(
         self,
         linker: str | Linker | None = None,
-        optimizer: str | RewriteDatabaseQuery = "default",
+        optimizer: str | RewriteDatabaseQuery | GraphRewriter = "default",
         db: RewriteDatabase = None,
     ):
         if linker is None:
@@ -377,9 +425,13 @@ class Mode:
     @property
     def optimizer(self):
         if isinstance(self._optimizer, RewriteDatabaseQuery):
-            return self.optdb.query(self._optimizer)
+            rewriter = self.optdb.query(self._optimizer)
         else:
-            return self._optimizer
+            rewriter = self._optimizer
+        # Stamp this mode as the fgraph's active compile mode while rewriting, so
+        # inner-graph rewrites can recover the right linker even when the optimizer
+        # is run directly (outside ``FunctionMaker``, e.g. ``mode.optimizer.rewrite(fgraph)``).
+        return _ActiveModeGraphRewriter(rewriter, self)
 
     def get_linker_optimizer(self, linker, optimizer):
         if isinstance(linker, str) or linker is None:
@@ -455,7 +507,7 @@ class Mode:
 
 C = Mode("c", "fast_run")
 CVM = Mode("cvm", "fast_run")
-VM = (Mode("vm", "fast_run"),)
+VM = Mode("vm", "fast_run")
 
 NUMBA = Mode(
     NumbaLinker(),

{pytensor-3.1.1 → pytensor-3.1.3}/pytensor/configdefaults.py

@@ -65,26 +65,6 @@ def _filter_mode(val):
     )
 
 
-def _split_version(version):
-    """
-    Take version as a dot-separated string, return a tuple of int
-    """
-    return tuple(int(i) for i in version.split("."))
-
-
-def _warn_default(version):
-    """
-    Return True iff we should warn about bugs fixed after a given version.
-    """
-    if config.warn__ignore_bug_before == "None":
-        return True
-    if config.warn__ignore_bug_before == "all":
-        return False
-    if _split_version(config.warn__ignore_bug_before) >= _split_version(version):
-        return False
-    return True
-
-
 def _is_valid_check_preallocated_output_param(param):
     if not isinstance(param, str):
         return False
@@ -591,47 +571,6 @@ def add_traceback_configvars():
 
 
 def add_error_and_warning_configvars():
-    ###
-    # To disable some warning about old bug that are fixed now.
-    ###
-    config.add(
-        "warn__ignore_bug_before",
-        (
-            "If 'None', we warn about all PyTensor bugs found by default. "
-            "If 'all', we don't warn about PyTensor bugs found by default. "
-            "If a version, we print only the warnings relative to PyTensor "
-            "bugs found after that version. "
-            "Warning for specific bugs can be configured with specific "
-            "[warn] flags."
-        ),
-        EnumStr(
-            "0.9",
-            [
-                "None",
-                "all",
-                "0.3",
-                "0.4",
-                "0.4.1",
-                "0.5",
-                "0.6",
-                "0.7",
-                "0.8",
-                "0.8.1",
-                "0.8.2",
-                "0.9",
-                "0.10",
-                "1.0",
-                "1.0.1",
-                "1.0.2",
-                "1.0.3",
-                "1.0.4",
-                "1.0.5",
-            ],
-            mutable=False,
-        ),
-        in_c_key=False,
-    )
-
     # Note to developers:
     # Generally your exceptions should use an apply node's __str__
     # method when exception_verbosity == 'low'. When exception_verbosity

{pytensor-3.1.1 → pytensor-3.1.3}/pytensor/configparser.py

@@ -101,7 +101,6 @@ class PyTensorConfigParser:
     traceback__limit: int
     traceback__compile_limit: int
     # add_error_and_warning_configvars
-    warn__ignore_bug_before: int
     exception_verbosity: str
     # add_testvalue_and_checking_configvars
     check_input: bool
@@ -138,8 +137,6 @@ class PyTensorConfigParser:
     optdb__max_use_ratio: float
     cycle_detection: str
     check_stack_trace: str
-    # add_metaopt_configvars
-    metaopt__verbose: int
     # add_vm_configvars
     profile: bool
     profile_optimizer: bool

{pytensor-3.1.1 → pytensor-3.1.3}/pytensor/gradient.py

@@ -139,7 +139,7 @@ class DisconnectedType(Type):
             " a symbolic placeholder."
         )
 
-    def fiter_variable(self, other):
+    def filter_variable(self, other):
         raise AssertionError(
             "If you're assigning to a DisconnectedType you're"
             " doing something wrong. It should only be used as"

{pytensor-3.1.1 → pytensor-3.1.3}/pytensor/graph/features.py

@@ -1,4 +1,3 @@
-import inspect
 import sys
 import time
 import warnings
@@ -693,32 +692,8 @@ class Validator(Feature):
             )
 
     def validate(self, fgraph):
-        """
-        If the caller is replace_all_validate, just raise the
-        exception. replace_all_validate will print out the
-        verbose output. Or it has to be done here before raise.
-        """
         t0 = time.perf_counter()
-        try:
-            ret = fgraph.execute_callbacks("on_validate")
-        except Exception as e:
-            cf = inspect.currentframe()
-            uf = cf.f_back
-            uf_info = inspect.getframeinfo(uf)
-
-            # If the caller is replace_all_validate, just raise the
-            # exception. replace_all_validate will print out the
-            # verbose output.
-            # Or it has to be done here before raise.
-            if uf_info.function == "replace_all_validate":
-                raise
-            else:
-                verbose = uf.f_locals.get("verbose", False)
-                if verbose:
-                    r = uf.f_locals.get("r", "")
-                    reason = uf_info.function
-                    print(f"validate failed on node {r}.\n Reason: {reason}, {e}")  # noqa: T201
-                raise
+        ret = fgraph.execute_callbacks("on_validate")
         t1 = time.perf_counter()
         if fgraph.profile:
             fgraph.profile.validate_time += t1 - t0

{pytensor-3.1.1 → pytensor-3.1.3}/pytensor/graph/rewriting/basic.py

@@ -1119,7 +1119,7 @@ class OpToRewriterTracker:
                     else:
                         # An OpPattern without parameters behaves like a regular tracked_type
                         self.tracked_types[c.op_type].append(rw)
-                if isinstance(c, type):
+                elif isinstance(c, type):
                     self.tracked_types[c].append(rw)
                 else:
                     self.tracked_instances[c].append(rw)