islpy 2025.2__tar.gz → 2025.2.2__tar.gz

{islpy-2025.2 → islpy-2025.2.2}/CMakeLists.txt

@@ -24,6 +24,7 @@ option(USE_IMATH_FOR_MP "Use IMATH for multiprecision arithmetic" ON)
 option(USE_IMATH_SIO "Use IMATH small-integer optimization" ON)
 option(USE_GMP_FOR_MP "Use GMP" OFF)
 option(USE_BARVINOK "Use Barvinok (beware of GPL license)" OFF)
+option(GENERATE_STUBS "Generate stubs as part of build" ON)
 
 if(USE_SHIPPED_ISL)
     if(USE_BARVINOK)
@@ -230,20 +231,26 @@ endif()
 
 install(TARGETS _isl LIBRARY DESTINATION islpy)
 
-set(ISLPY_STUB_FILE ${CMAKE_BINARY_DIR}/_isl.pyi)
-add_custom_command(
-    OUTPUT ${ISLPY_STUB_FILE}
-    COMMAND ${Python_EXECUTABLE} ${CMAKE_SOURCE_DIR}/stubgen/stubgen.py
-        -o ${CMAKE_BINARY_DIR}
-        --exec ${CMAKE_SOURCE_DIR}/islpy/_monkeypatch.py
-        --python-path ${CMAKE_BINARY_DIR}
-        -m _isl
-    DEPENDS _isl
-)
-add_custom_target(
-    _isl_stub
-    ALL DEPENDS ${CMAKE_BINARY_DIR}/_isl.pyi
-)
-install(FILES ${ISLPY_STUB_FILE} DESTINATION islpy)
+if(GENERATE_STUBS)
+    set(ISLPY_STUB_FILE ${CMAKE_BINARY_DIR}/_isl.pyi)
+    add_custom_command(
+        OUTPUT ${ISLPY_STUB_FILE}
+        COMMAND ${Python_EXECUTABLE} ${CMAKE_SOURCE_DIR}/stubgen/stubgen.py
+            -o ${CMAKE_BINARY_DIR}
+            --exec ${CMAKE_SOURCE_DIR}/islpy/_monkeypatch.py
+            --python-path ${CMAKE_BINARY_DIR}
+            -m _isl
+        DEPENDS _isl
+    )
+    add_custom_target(
+        _isl_stub
+        ALL DEPENDS ${CMAKE_BINARY_DIR}/_isl.pyi
+    )
+    install(FILES ${ISLPY_STUB_FILE} DESTINATION islpy)
+else()
+    if(NOT EXISTS "${CMAKE_SOURCE_DIR}/islpy/_isl.pyi")
+        message(FATAL_ERROR "Disabled stub generation requires pregenerated stubs")
+    endif()
+endif()
 
 # vim: sw=2

{islpy-2025.2 → islpy-2025.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: islpy
-Version: 2025.2
+Version: 2025.2.2
 Summary: Wrapper around isl, an integer set library
 Author-Email: Andreas Kloeckner <inform@tiker.net>
 License-Expression: MIT

{islpy-2025.2 → islpy-2025.2.2}/doc/misc.rst

@@ -16,9 +16,10 @@ You may also clone its git repository::
 
 The following attempts an editable installation, however note
 that this may run into various issues and is not well-supported
-by the build tools::
+by the build tools. In particular, build isolation must be turned off::
 
-    $ pip install --no-build-isolation -e .
+    pip install cmake scikit_build_core nanobind pcpp  # prerequisites
+    pip install --no-build-isolation --config-settings=build-dir=build -ve .
 
 Support
 =======

{islpy-2025.2 → islpy-2025.2.2}/examples/demo.py

@@ -13,39 +13,36 @@ print("set 1 %s:" % bset)
 bset2 = isl.BasicSet("{[x, y] : x >= 0 and x < 5 and y >= 0 and y < x+4 }")
 print("set 2: %s" % bset2)
 
-bsets_in_union = []
-bset.union(bset2).convex_hull().foreach_basic_set(bsets_in_union.append)
-print(bsets_in_union)
-union, = bsets_in_union
-print("union: %s" % union)
+union_ch = (bset.to_set() | bset2).convex_hull()
+print("convex hull of union: %s" % union_ch)
 # ENDEXAMPLE
 
 import matplotlib.pyplot as pt
 
 
-def plot_basic_set(bset, *args, **kwargs):
+def plot_basic_set(bset: isl.BasicSet, *args, **kwargs):
     # This is a total hack. But it works for what it needs to do. :)
 
     plot_vert = kwargs.pop("plot_vert", False)
 
-    vertices = []
+    vertices: list[isl.Vertex] = []
     bset.compute_vertices().foreach_vertex(vertices.append)
 
-    vertex_pts = []
+    vertex_pts: list[list[int]] = []
 
     for v in vertices:
-        points = []
+        points: list[isl.Point] = []
         myset = isl.BasicSet.from_multi_aff(v.get_expr())
-        myset.foreach_point(points.append)
+        myset.to_set().foreach_point(points.append)
         point, = points
         vertex_pts.append([
             point.get_coordinate_val(isl.dim_type.set, i).to_python()
             for i in range(2)])
 
     import numpy as np
-    vertex_pts = np.array(vertex_pts)
+    vertex_pts_ary = np.array(vertex_pts)
 
-    center = np.average(vertex_pts, axis=0)
+    center = np.average(vertex_pts_ary, axis=0)
 
     from math import atan2
     vertex_pts = np.array(
@@ -80,6 +77,6 @@ pt.ylim([-1, 8])
 # pt.show()
 pt.savefig("before-union.png", dpi=50)
 
-plot_basic_set(union, facecolor="blue", edgecolor="yellow",
+plot_basic_set(union_ch, facecolor="blue", edgecolor="yellow",
         alpha=0.5, plot_vert=True)
 pt.savefig("after-union.png", dpi=50)

{islpy-2025.2 → islpy-2025.2.2}/gen_wrap.py

@@ -252,7 +252,7 @@ CLASS_MAP = {
         "options": "ctx",
         }
 
-AUTO_UPCASTS: Mapping[str, tuple[str, ...]] = {
+AUTO_DOWNCASTS: Mapping[str, tuple[str, ...]] = {
     "pw_aff": ("aff", ),
     "union_pw_aff": ("aff", "pw_aff", ),
     "local_space": ("space", ),
@@ -1140,7 +1140,7 @@ def write_wrapper(outf: TextIO, meth: Method):
             else:
                 acceptable_arg_classes = (
                     arg_cls,
-                    *AUTO_UPCASTS.get(arg_cls, ()))
+                    *AUTO_DOWNCASTS.get(arg_cls, ()))
                 arg_annotation = " | ".join(
                     to_py_class(ac) for ac in acceptable_arg_classes)
                 arg_types.append(f"{arg.name}: {arg_annotation}")
@@ -1313,7 +1313,7 @@ def write_wrapper(outf: TextIO, meth: Method):
             body.append(f"arg_{meth.args[0].name}.take_possession_of(result);")
             body.append(f"return py_{meth.args[0].name};")
 
-            ret_type = to_py_class(ret_cls)
+            ret_type = "Self"
             docs.append("..note::\n  Returns *self*.\n\n")
         else:
             processed_return_type = "py::object"
@@ -1481,8 +1481,9 @@ def write_exposer(
             f'       isl::handle_isl_error(ctx, "isl_{meth.cls}_read_from_str");'
             '}, py::arg("s"), py::arg("context").none(true)=py::none());\n')
 
+    # Handle auto-self-downcasts. These are deprecated.
     if not meth.is_static:
-        for basic_cls in AUTO_UPCASTS.get(meth.cls, []):
+        for basic_cls in AUTO_DOWNCASTS.get(meth.cls, []):
             basic_overloads = meth_to_overloads.setdefault((basic_cls, meth.name), [])
             if any(basic_meth
                    for basic_meth in basic_overloads
@@ -1491,13 +1492,22 @@ def write_exposer(
                    ):
                 continue
 
+            # These are high-traffic APIs that are manually implemented
+            # and not subject to deprecation.
+            if basic_cls == "basic_set":
+                if meth.name in ["is_params", "get_hash"]:
+                    continue
+            elif basic_cls == "basic_map":
+                if meth.name in ["get_hash"]:
+                    continue
+
             basic_overloads.append(meth)
 
-            upcast_doc_str = (f"{doc_str}\n\nUpcast from "
+            downcast_doc_str = (f"{doc_str}\n\nDowncast from "
                 f":class:`{to_py_class(basic_cls)}` to "
                 f":class:`{to_py_class(meth.cls)}`.")
-            escaped_doc_str = upcast_doc_str.replace(newline, escaped_newline)
-            outf.write(f"// automatic upcast to {meth.cls}\n")
+            escaped_doc_str = downcast_doc_str.replace(newline, escaped_newline)
+            outf.write(f"// automatic downcast to {meth.cls}\n")
             outf.write(f'wrap_{basic_cls}.def('
                        # Do not be tempted to pass 'arg_str' here, it will
                        # prevent implicit conversion.

{islpy-2025.2 → islpy-2025.2.2}/islpy/__init__.py

@@ -21,7 +21,7 @@ THE SOFTWARE.
 """
 
 from collections.abc import Collection, Sequence
-from typing import Literal, TypeAlias, TypeVar
+from typing import Literal, TypeAlias, TypeVar, cast
 
 from islpy.version import VERSION, VERSION_TEXT
 
@@ -149,44 +149,34 @@ def _get_default_context() -> Context:
     return DEFAULT_CONTEXT
 
 
-def _back_to_basic(new_obj, old_obj):
-    # Work around set_dim_id not being available for Basic{Set,Map}
-    if isinstance(old_obj, BasicSet) and isinstance(new_obj, Set):
-        bsets = new_obj.get_basic_sets()
+def _set_dim_id(obj: AlignableT, dt: dim_type, idx: int, id: Id) -> AlignableT:
+    if isinstance(obj, BasicSet):
+        p, = obj.to_set().set_dim_id(dt, idx, id).get_basic_sets()
+        return cast("AlignableT", p)
+    elif isinstance(obj, BasicMap):
+        p, = obj.to_map().set_dim_id(dt, idx, id).get_basic_maps()
+        return cast("AlignableT", p)
 
-        if len(bsets) == 0:
-            bset = BasicSet.universe(new_obj.space).complement()
-        else:
-            bset, = bsets
-
-        return bset
-
-    if isinstance(old_obj, BasicMap) and isinstance(new_obj, Map):
-        bmaps = new_obj.get_basic_maps()
-
-        if len(bmaps) == 0:
-            bmap = BasicMap.universe(new_obj.space).complement()
-        else:
-            bmap, = bmaps
-
-        return bmap
-
-    return new_obj
-
-
-def _set_dim_id(obj, dt, idx, id):
-    return _back_to_basic(obj.set_dim_id(dt, idx, id), obj)
+    return cast("AlignableT", obj.set_dim_id(dt, idx, id))
 
 
 def _align_dim_type(
             template_dt: dim_type,
             obj: AlignableT,
-            template: AlignableT,
+            template: Alignable,
             obj_bigger_ok: bool,
             obj_names: Collection[str],
             template_names: Collection[str],
         ) -> AlignableT:
 
+    # convert to a type that has get_dim_id
+    if isinstance(template, BasicSet):
+        template = template.to_set()
+    elif isinstance(template, BasicMap):
+        template = template.to_map()
+    elif isinstance(template, Aff):
+        template = template.to_pw_aff()
+
     # {{{ deal with Aff, PwAff
 
     # The technique below will not work for PwAff et al, because there is *only*

{islpy-2025.2 → islpy-2025.2.2}/islpy/_monkeypatch.py

@@ -1,14 +1,21 @@
+import os
+import re
 from collections.abc import Callable, Collection, Iterable, Mapping, Sequence
+from functools import update_wrapper
+from sys import intern
 from typing import (
     TYPE_CHECKING,
     Any,
     ClassVar,
+    Concatenate,
     Literal,
+    ParamSpec,
     Protocol,
     TypeAlias,
     TypeVar,
     cast,
 )
+from warnings import warn
 
 
 if TYPE_CHECKING:
@@ -544,6 +551,8 @@ def obj_get_var_names(self: HasSpace, dimtype: _isl.dim_type) -> Sequence[str]:
 
 
 def pwaff_get_pieces(self: _isl.PwAff | _isl.Aff) -> list[tuple[_isl.Set, _isl.Aff]]:
+    if isinstance(self, _isl.Aff):
+        self = self.to_pw_aff()
     result: list[tuple[_isl.Set, _isl.Aff]] = []
 
     def append_tuple(s: _isl.Set, v: _isl.Aff):
@@ -1013,3 +1022,78 @@ for cls in ALL_CLASSES:
 
 
 _add_functionality()
+
+
+P = ParamSpec("P")
+ResultT = TypeVar("ResultT")
+
+
+_DOWNCAST_RE = re.compile(
+          r"Downcast from :class:`([A-Za-z]+)` to :class:`([A-Za-z]+)`.")
+
+
+_TO_METHODS = {
+    "PwAff": "to_pw_aff",
+    "PwMultiAff": "to_pw_multi_aff",
+    "UnionPwAff": "to_union_pw_aff",
+    "UnionPwMultiAff": "to_union_pw_multi_aff",
+    "LocalSpace": "to_local_space",
+    "Set": "to_set",
+    "UnionSet": "to_union_set",
+    "Map": "to_map",
+    "UnionMap": "to_union_map",
+}
+
+
+def _depr_downcast_wrapper(
+            f: Callable[Concatenate[object, P], ResultT],
+        ) -> Callable[Concatenate[object, P], ResultT]:
+    doc = f.__doc__
+    assert doc is not None
+    m = _DOWNCAST_RE.search(doc)
+    assert m, doc
+    basic_cls_name = intern(m.group(1))
+    tgt_cls_name = m.group(2)
+
+    tgt_cls = cast("type", getattr(_isl, tgt_cls_name))
+    is_overload = "Overloaded function" in doc
+    msg = (f"{basic_cls_name}.{f.__name__} "
+            f"with implicit conversion of self to {tgt_cls_name} is deprecated "
+            "and will stop working in 2026. "
+            f"Explicitly convert to {tgt_cls_name}, "
+            f"using .{_TO_METHODS[tgt_cls_name]}().")
+
+    if is_overload:
+        def wrapper(self: object, *args: P.args, **kwargs: P.kwargs) -> ResultT:
+            # "Try to" detect bad invocations of, e.g., Set.union, which is
+            # an overload of normal union and UnionSet.union.
+            if (
+                    any(isinstance(arg, tgt_cls) for arg in args)
+                    or
+                    any(isinstance(arg, tgt_cls) for arg in kwargs.values())
+                    ):
+                warn(msg, DeprecationWarning, stacklevel=2)
+
+            return f(self, *args, **kwargs)
+    else:
+        def wrapper(self: object, *args: P.args, **kwargs: P.kwargs) -> ResultT:
+            warn(msg, DeprecationWarning, stacklevel=2)
+
+            return f(self, *args, **kwargs)
+    update_wrapper(wrapper, f)
+    return wrapper
+
+
+def _monkeypatch_self_downcast_deprecation():
+    for cls in ALL_CLASSES:
+        for attr_name in dir(cls):
+            val = cast("object", getattr(cls, attr_name))
+            doc = getattr(val, "__doc__", None)
+            if doc and "\nDowncast from " in doc:
+                setattr(cls, attr_name, _depr_downcast_wrapper(
+                        cast("Callable", val),  # pyright: ignore[reportMissingTypeArgument]
+                        ))
+
+
+if not os.environ.get("ISLPY_NO_DOWNCAST_DEPRECATION", None):
+    _monkeypatch_self_downcast_deprecation()

{islpy-2025.2 → islpy-2025.2.2}/pyproject.toml

@@ -2,7 +2,7 @@
 build-backend = "scikit_build_core.build"
 requires = [
     "scikit-build-core >=0.9.3",
-    "nanobind >=1.9.2",
+    "nanobind >=2.7",
     "pcpp",
 
     # stubgen uses @override :/
@@ -11,7 +11,7 @@ requires = [
 
 [project]
 name = "islpy"
-version = "2025.2"
+version = "2025.2.2"
 description = "Wrapper around isl, an integer set library"
 readme = "README.rst"
 license = "MIT"

{islpy-2025.2 → islpy-2025.2.2}/src/wrapper/wrap_isl.hpp

@@ -343,4 +343,10 @@ namespace isl
   wrap_##name.attr("_base_name") = #name; \
   wrap_##name.attr("_isl_name") = "isl_"#name; \
 
+#define MAKE_TO_METHOD(from, to) \
+  wrap_##from.def("to_" #to, [](isl::from const &s) { return new isl::to(s); });
+#define MAKE_INIT_CONVERTIBLE(from, to) \
+  wrap_##to.def(py::init_implicit<isl::from const &>());
+
+
 // vim: foldmethod=marker

{islpy-2025.2 → islpy-2025.2.2}/src/wrapper/wrap_isl_part1.cpp

@@ -112,21 +112,21 @@ void islpy_expose_part1(py::module_ &m)
   MAKE_WRAP(aff, Aff);
 
   MAKE_WRAP(pw_aff, PwAff);
-  wrap_pw_aff.def(py::init_implicit<isl::aff const &>());
+  MAKE_INIT_CONVERTIBLE(aff, pw_aff);
+  MAKE_TO_METHOD(aff, pw_aff);
 
   MAKE_WRAP(union_pw_aff, UnionPwAff);
-  wrap_union_pw_aff.def(py::init_implicit<isl::aff const &>());
-  wrap_union_pw_aff.def(py::init_implicit<isl::pw_aff const &>());
+  MAKE_INIT_CONVERTIBLE(pw_aff, union_pw_aff);
 
   MAKE_WRAP(multi_id, MultiId);
 
   MAKE_WRAP(multi_aff, MultiAff);
 
   MAKE_WRAP(pw_multi_aff, PwMultiAff);
-  wrap_pw_multi_aff.def(py::init_implicit<isl::multi_aff const &>());
+  MAKE_INIT_CONVERTIBLE(multi_aff, pw_multi_aff)
 
   MAKE_WRAP(union_pw_multi_aff, UnionPwMultiAff);
-  wrap_union_pw_multi_aff.def(py::init_implicit<isl::pw_multi_aff const &>());
+  MAKE_INIT_CONVERTIBLE(pw_multi_aff, union_pw_multi_aff)
 
   MAKE_WRAP(multi_pw_aff, MultiPwAff);
 
@@ -169,7 +169,8 @@ void islpy_expose_part1(py::module_ &m)
 
   MAKE_WRAP(space, Space);
   MAKE_WRAP(local_space, LocalSpace);
-  wrap_local_space.def(py::init_implicit<isl::space const &>());
+  MAKE_INIT_CONVERTIBLE(space, local_space);
+  MAKE_TO_METHOD(space, local_space);
 
 #include "gen-expose-part1.inc"
 }

islpy-2025.2.2/src/wrapper/wrap_isl_part2.cpp

@@ -0,0 +1,50 @@
+#include "wrap_isl.hpp"
+
+namespace isl
+{
+#include "gen-wrap-part2.inc"
+}
+
+void islpy_expose_part2(py::module_ &m)
+{
+  MAKE_WRAP(basic_set, BasicSet);
+  wrap_basic_set.def("__hash__", [](isl::basic_set const &self) {
+                       isl::set set_self(self);
+                       return isl_set_get_hash(set_self.m_data);
+                     });
+  // used in align_dims
+  wrap_basic_set.def("is_params", [](isl::basic_set const &self) {
+                       isl::set set_self(self);
+                       return bool(isl_set_is_params(set_self.m_data));
+                     });
+
+  MAKE_WRAP(basic_map, BasicMap);
+  wrap_basic_map.def("__hash__", [](isl::basic_map const &self) {
+                       isl::map map_self(self);
+                       return isl_map_get_hash(map_self.m_data);
+                     });
+
+  MAKE_WRAP(set, Set);
+  MAKE_INIT_CONVERTIBLE(basic_set, set);
+
+  MAKE_WRAP(map, Map);
+  MAKE_INIT_CONVERTIBLE(basic_map, map);
+  MAKE_TO_METHOD(basic_map, map);
+
+  MAKE_WRAP(union_set, UnionSet);
+  MAKE_INIT_CONVERTIBLE(set, union_set);
+
+  MAKE_WRAP(union_map, UnionMap);
+  MAKE_INIT_CONVERTIBLE(map, union_map);
+
+  MAKE_WRAP(point, Point);
+
+  MAKE_WRAP(vertex, Vertex);
+
+  MAKE_WRAP(cell, Cell);
+
+  MAKE_WRAP(vertices, Vertices);
+  MAKE_WRAP(stride_info, StrideInfo);
+
+#include "gen-expose-part2.inc"
+}

{islpy-2025.2 → islpy-2025.2.2}/stubgen/stubgen.py

@@ -1,5 +1,6 @@
 import argparse
 import importlib
+import os
 import sys
 from collections.abc import Callable
 from pathlib import Path
@@ -60,6 +61,7 @@ def main():
 
     sys.path.extend(cast("list[str]", args.python_path or []))
 
+    os.environ["ISLPY_NO_DOWNCAST_DEPRECATION"] = "1"
     mod = importlib.import_module(cast("str", args.module))
     for fname in cast("list[str]", args.exec or []):
         execdict = {"__name__": "islpy._monkeypatch"}
@@ -74,6 +76,7 @@ def main():
     )
     sg.put(mod)
     prefix_lines = "\n".join([
+        "from typing_extensions import Self",
         "from collections.abc import Callable",
     ])
     with open(output_path / "_isl.pyi", "w") as outf:

{islpy-2025.2 → islpy-2025.2.2}/test/test_isl.py

@@ -45,7 +45,7 @@ def test_basics():
             context=ctx)
 
     points = []
-    bset.foreach_point(points.append)
+    bset.to_set().foreach_point(points.append)
 
     for pt in points:
         print(pt)
@@ -160,12 +160,14 @@ def test_get_coefficients_by_name():
 def test_count_brick_ish():
     a = isl.BasicSet("[n] -> {[i,j]: 0<= i < n and 0<= j < n and j<= i}")
 
-    def count(bset):
+    def count(set):
+        if isinstance(set, isl.BasicSet):
+            set = set.to_set()
         result = 1
 
-        for i in range(bset.dim(isl.dim_type.set)):
-            dmax = bset.dim_max(i)
-            dmin = bset.dim_min(i)
+        for i in range(set.dim(isl.dim_type.set)):
+            dmax = set.dim_max(i)
+            dmin = set.dim_min(i)
 
             length = isl.PwQPolynomial.from_pw_aff(dmax - dmin + 1)
 

islpy-2025.2/src/wrapper/wrap_isl_part2.cpp

@@ -1,36 +0,0 @@
-#include "wrap_isl.hpp"
-
-namespace isl
-{
-#include "gen-wrap-part2.inc"
-}
-
-void islpy_expose_part2(py::module_ &m)
-{
-  MAKE_WRAP(basic_set, BasicSet);
-
-  MAKE_WRAP(basic_map, BasicMap);
-
-  MAKE_WRAP(set, Set);
-  wrap_set.def(py::init_implicit<isl::basic_set const &>());
-
-  MAKE_WRAP(map, Map);
-  wrap_map.def(py::init_implicit<isl::basic_map const &>());
-
-  MAKE_WRAP(union_set, UnionSet);
-  wrap_union_set.def(py::init_implicit<isl::set const &>());
-
-  MAKE_WRAP(union_map, UnionMap);
-  wrap_union_map.def(py::init_implicit<isl::map const &>());
-
-  MAKE_WRAP(point, Point);
-
-  MAKE_WRAP(vertex, Vertex);
-
-  MAKE_WRAP(cell, Cell);
-
-  MAKE_WRAP(vertices, Vertices);
-  MAKE_WRAP(stride_info, StrideInfo);
-
-#include "gen-expose-part2.inc"
-}