pytensor 3.1.2__tar.gz → 3.1.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytensor
-Version: 3.1.2
+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.2 → 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.2 → 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.2 → pytensor-3.1.3}/pytensor/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2026-07-06T16:55:07+0200",
+ "date": "2026-07-10T22:43:47+0200",
  "dirty": false,
  "error": null,
- "full-revisionid": "47d3d0e3721d0488734b84051da78031081c7dc2",
- "version": "3.1.2"
+ "full-revisionid": "4c7f21181b616d2e05310a518c87cc661ba1b97e",
+ "version": "3.1.3"
 }
 '''  # END VERSION_JSON
 

{pytensor-3.1.2 → 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.2 → 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.2 → 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.
 
@@ -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.2 → 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.2 → 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.2 → 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.2 → 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.2 → 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)

pytensor-3.1.3/pytensor/graph/rewriting/utils.py

@@ -0,0 +1,116 @@
+from collections.abc import Generator, Iterable, Sequence
+from typing import TYPE_CHECKING, Optional, cast
+
+from pytensor.graph.basic import (
+    Apply,
+    Variable,
+)
+from pytensor.graph.fg import FunctionGraph, Output
+from pytensor.graph.rewriting.db import RewriteDatabaseQuery
+
+
+if TYPE_CHECKING:
+    from pytensor.graph.rewriting.basic import GraphRewriter
+
+
+def rewrite_graph(
+    graph: Variable | Sequence[Variable] | FunctionGraph,
+    include: Sequence[str] = ("canonicalize",),
+    custom_rewrite: Optional["GraphRewriter"] = None,
+    clone: bool = False,
+    **kwargs,
+) -> Variable | Sequence[Variable] | FunctionGraph:
+    """Easily apply rewrites to a graph.
+
+    Parameters
+    ----------
+    graph
+        A `FunctionGraph` or `Variable` to be rewritten.
+    include
+        String names of the rewrites to be queried, via a
+        `RewriteDatabaseQuery` instance, and applied.  The default rewrite
+        query string is ``"canonicalization"``.
+    custom_rewrite
+        A custom `Rewriter` to also be applied.
+    clone
+        Whether or not to clone the input graph before rewriting.
+    **kwargs
+        Keyword arguments passed to a `RewriteDatabaseQuery` object.
+    """
+    from pytensor.compile import optdb
+
+    if isinstance(graph, FunctionGraph):
+        fgraph = graph
+    else:
+        outputs = [graph] if isinstance(graph, Variable) else graph
+        fgraph = FunctionGraph(outputs=outputs, clone=clone, copy_inputs=False)
+
+    query_rewrites = optdb.query(RewriteDatabaseQuery(include=include, **kwargs))
+    query_rewrites.rewrite(fgraph)
+
+    if custom_rewrite is not None:
+        custom_rewrite.rewrite(fgraph)
+
+    if isinstance(graph, FunctionGraph):
+        return fgraph
+    if isinstance(graph, Variable):
+        return fgraph.outputs[0]
+    return fgraph.outputs
+
+
+def rewrite_subgraph(
+    outputs: Sequence[Variable],
+    frontier: Iterable[Variable],
+    include: Sequence[str] = ("canonicalize",),
+    **kwargs,
+) -> list[Variable]:
+    """Rewrite the subgraph between ``frontier`` and ``outputs`` in isolation.
+
+    The ``frontier`` variables are temporarily detached from their owners, so
+    they act as inputs of the subgraph: rewrites can neither reach past them
+    nor modify the graph they belong to. This allows simplifying fresh
+    expressions that hang off the variables of an existing `FunctionGraph`
+    without mutating it behind its (and its features') back.
+
+    The rewrite is in place: ``outputs`` must not belong to a `FunctionGraph`.
+
+    Parameters
+    ----------
+    outputs
+        The outputs of the subgraph to rewrite.
+    frontier
+        Variables at which the subgraph stops; every path from ``outputs``
+        into the surrounding graph must go through one of them.
+    include
+        Rewrite query names, as in `rewrite_graph`.
+    **kwargs
+        Keyword arguments passed to `rewrite_graph`.
+    """
+    saved_owners = [(v, v.owner, v.index) for v in frontier]
+    for v, _, _ in saved_owners:
+        v.owner = None
+    try:
+        rewritten = cast(
+            Sequence[Variable],
+            rewrite_graph(list(outputs), include=include, clone=False, **kwargs),
+        )
+        return list(rewritten)
+    finally:
+        for v, owner, idx in saved_owners:
+            v.owner = owner
+            v.index = idx
+
+
+def get_clients_at_depth(
+    fgraph: FunctionGraph, node: Apply, depth: int
+) -> Generator[Apply, None, None]:
+    """Yields node clients at given depth."""
+    for var in node.outputs:
+        if depth > 0:
+            for out_node, _ in fgraph.clients[var]:
+                if isinstance(out_node.op, Output):
+                    continue
+                yield from get_clients_at_depth(fgraph, out_node, depth - 1)
+        else:
+            assert var.owner is not None
+            yield var.owner

{pytensor-3.1.2 → pytensor-3.1.3}/pytensor/graph/type.py

@@ -96,34 +96,6 @@ class Type(MetaObject, Generic[D]):  # noqa: UP046
 
         """
 
-    def filter_inplace(
-        self,
-        value: Any,
-        storage: Any,
-        strict: bool = False,
-        allow_downcast: bool | None = None,
-    ):
-        """Return data or an appropriately wrapped/converted data by converting it in-place.
-
-        This method allows one to reuse old allocated memory.  If this method
-        is implemented, it will be called instead of `Type.filter`.
-
-        As of now, this method is not implemented and was previously used for transferring memory to and from GPU.
-
-        Parameters
-        ----------
-        value: array-like
-        storage: array-like
-            The old value (e.g. the old NumPy array)
-        strict: bool
-        allow_downcast: bool (optional)
-
-        Raises
-        ------
-        NotImplementedError
-        """
-        raise NotImplementedError()
-
     def filter_variable(
         self, other: Variable | D, allow_convert: bool = True
     ) -> variable_type:

{pytensor-3.1.2 → pytensor-3.1.3}/pytensor/link/basic.py

@@ -97,13 +97,7 @@ class Container:
             if self.allow_downcast is not None:
                 kwargs["allow_downcast"] = self.allow_downcast
 
-            try:
-                # Use in-place filtering when/if possible
-                self.storage[0] = self.type.filter_inplace(
-                    value, self.storage[0], **kwargs
-                )
-            except NotImplementedError:
-                self.storage[0] = self.type.filter(value, **kwargs)
+            self.storage[0] = self.type.filter(value, **kwargs)
 
         except Exception as e:
             e.args = (*e.args, f'Container name "{self.name}"')

{pytensor-3.1.2 → pytensor-3.1.3}/pytensor/link/c/cmodule.py

@@ -58,15 +58,6 @@ def is_StdLibDirsAndLibsType(
     return cast(StdLibDirsAndLibsType, fn)
 
 
-class GCCLLVMType(Protocol):
-    is_llvm: bool | None
-    __call__: Callable[[], bool | None]
-
-
-def is_GCCLLVMType(fn: Callable[[], bool | None]) -> GCCLLVMType:
-    return cast(GCCLLVMType, fn)
-
-
 _logger = logging.getLogger("pytensor.link.c.cmodule")
 
 METH_VARARGS = "METH_VARARGS"
@@ -262,10 +253,7 @@ def _get_ext_suffix():
     """Get the suffix for compiled extensions"""
     from setuptools._distutils.sysconfig import get_config_var
 
-    dist_suffix = get_config_var("EXT_SUFFIX")
-    if dist_suffix is None:
-        dist_suffix = get_config_var("SO")
-    return dist_suffix
+    return get_config_var("EXT_SUFFIX")
 
 
 def add_gcc_dll_directory() -> AbstractContextManager[None]:
@@ -1817,33 +1805,6 @@ def std_lib_dirs():
     return std_lib_dirs_and_libs()[1]
 
 
-@is_GCCLLVMType
-def gcc_llvm() -> bool | None:
-    """
-    Detect if the g++ version used is the llvm one or not.
-
-    It don't support all g++ parameters even if it support many of them.
-
-    """
-    if gcc_llvm.is_llvm is None:
-        try:
-            p_out = output_subprocess_Popen([config.cxx, "--version"])
-            output = p_out[0] + p_out[1]
-        except OSError:
-            # Typically means g++ cannot be found.
-            # So it is not an llvm compiler.
-
-            # Normally this should not happen as we should not try to
-            # compile when g++ is not available. If this happen, it
-            # will crash later so supposing it is not llvm is "safe".
-            output = b""
-        gcc_llvm.is_llvm = b"llvm" in output
-    return gcc_llvm.is_llvm
-
-
-gcc_llvm.is_llvm = None
-
-
 class Compiler:
     """
     Meta compiler that offer some generic function.

{pytensor-3.1.2 → pytensor-3.1.3}/pytensor/link/c/op.py

@@ -217,7 +217,6 @@ int main( int argc, const char* argv[] )
                     )
             if OpenMPOp.gxx_support_openmp is False:
                 self.openmp = False
-                config.openmp = False
 
     def prepare_node(self, node, storage_map, compute_map, impl):
         if impl == "c":