Renovating adapters x1

Author: james-d-mitchell

libsemigroups_pybind11/action.py

@@ -202,6 +202,7 @@ def __init__(
         """
 
         super().__init__(
+            *args,
             required_kwargs=("func", "side", "seeds", "generators"),
             generators=generators,
             seeds=seeds,

libsemigroups_pybind11/adapters.py

@@ -13,77 +13,68 @@
 various adapters from libsemigroups.
 """
 
-from typing import Any
+from typing import Any, Union, Iterator, TypeVar as _TypeVar, List
 
-from typing_extensions import Self
+from typing_extensions import Self as _Self
 
 from _libsemigroups_pybind11 import (
-    ImageRightActionBMat8BMat8 as _ImageRightActionBMat8BMat8,
-    ImageLeftActionBMat8BMat8 as _ImageLeftActionBMat8BMat8,
-    ImageRightActionPPerm1PPerm1 as _ImageRightActionPPerm1PPerm1,
-    ImageLeftActionPPerm1PPerm1 as _ImageLeftActionPPerm1PPerm1,
-    ImageRightActionPPerm1List as _ImageRightActionPPerm1List,
     # TODO Transf
     # TODO other pperms
     BMat8 as _BMat8,
+    ImageLeftActionBMat8BMat8 as _ImageLeftActionBMat8BMat8,
+    ImageLeftActionPPerm1PPerm1 as _ImageLeftActionPPerm1PPerm1,
+    ImageRightActionBMat8BMat8 as _ImageRightActionBMat8BMat8,
+    ImageRightActionPPerm1List as _ImageRightActionPPerm1List,
+    ImageRightActionPPerm1PPerm1 as _ImageRightActionPPerm1PPerm1,
     PPerm1 as _PPerm1,
 )
 
-from .detail.cxx_wrapper import CxxWrapper, to_cxx, to_py
+from .detail.cxx_wrapper import (
+    CxxWrapper as _CxxWrapper,
+    to_cxx as _to_cxx,
+    to_py_new as _to_py,
+)
 
 from .tools import ordinal
-from .transf import PPerm
-
-
-class _ImageAction(CxxWrapper):
-    def __init__(self: Self, **kwargs):
-        super().__init__(required_kwargs=("Element", "Point"), **kwargs)
-        self.Element = kwargs["Element"]
-        self.Point = kwargs["Point"]
-
-    def _init_cxx_obj(self: Self, elt: Any, pt: Any) -> Any:
-        cxx_obj_t = self._cxx_obj_type_from(samples=(elt, pt))
-        if self._cxx_obj is None or not isinstance(self._cxx_obj, cxx_obj_t):
-            self._cxx_obj = cxx_obj_t()
-        return self._cxx_obj
-
-    def __call__(  # pylint: disable=inconsistent-return-statements
-        self: Self, *args
-    ):
-        # Point1, Point2, Element -> Point1 = Point2 ^ Element
-        if 2 > len(args) or len(args) > 3:
-            raise TypeError(f"expected 2 or 3 arguments, found {len(args)}")
-        pt = args[-2]
-        x = args[-1]
-        if not isinstance(pt, self.Point):
-            raise ValueError(
-                f"the {ordinal(len(args) - 2)} argument (point) has incorrect type, "
-                f"expected {self.Point} but found {type(pt)}"
-            )
-        if not isinstance(x, self.Element):
-            raise ValueError(
-                f"the {ordinal(len(args) - 1)} argument (element) has incorrect type, "
-                f"expected {self.Element} but found {type(x)}"
-            )
-        if len(args) == 3:
-            res = args[0]
-            if not isinstance(res, self.Point):
-                raise ValueError(
-                    "the 1st argument (result) has incorrect type, "
-                    f"expected {self.Point} but found {type(res)}"
-                )
-        if len(args) == 3 and self.Point is list:
-            raise NotImplementedError("not yet implemented")
-
-        self._init_cxx_obj(x, pt)
-        return to_py(
-            self.Element, self._cxx_obj(*(to_cxx(arg) for arg in args))
+from .transf import PPerm as _PPerm
+
+
+class _ImageAction(_CxxWrapper):
+    """
+    This is a protected base class for ImageRightAction and ImageLeftAction.
+    """
+
+    Element = _TypeVar("Element")
+    Point = _TypeVar("Point")
+
+    def __init__(self: _Self, *args, point=None, element=None) -> None:
+        """
+        TODO
+        Note to self <point> and <element> are the types of the objects used by
+        this function not examples of such objects.
+        """
+        super().__init__(
+            *args,
+            required_kwargs=("element", "point"),
+            point=point,
+            element=element,
+        )
+        if _to_cxx(self) is not None:
+            return
+        if len(args) != 0:
+            raise ValueError(f"expected 0 positional arguments, but found {len(args)}")
+        self.py_template_params = (
+            type(_to_cxx(element)),
+            type(_to_cxx(point)),
         )
+        self.init_cxx_obj()
+
+    def __call__(self: _Self, *args):
+        return _to_py(_to_cxx(self)(*(_to_cxx(x) for x in args)))
 
 
 class ImageRightAction(_ImageAction):
-    # pylint: disable=too-few-public-methods, unused-private-member
-    """
+    """TODO update
     Construct a ImageRightAction instance.
 
     :Keyword Arguments:
@@ -93,18 +84,22 @@ class ImageRightAction(_ImageAction):
 
     _py_template_params_to_cxx_type = {
         (_BMat8, _BMat8): _ImageRightActionBMat8BMat8,
-        (PPerm, PPerm): {
-            (_PPerm1, _PPerm1): _ImageRightActionPPerm1PPerm1,
-        },
-        (PPerm, list): {
-            (_PPerm1, list): _ImageRightActionPPerm1List,
-        },
+        (_PPerm1, _PPerm1): _ImageRightActionPPerm1PPerm1,
+        (_PPerm1, list): _ImageRightActionPPerm1List,
     }
 
+    _cxx_type_to_py_template_params = dict(
+        zip(
+            _py_template_params_to_cxx_type.values(),
+            _py_template_params_to_cxx_type.keys(),
+        )
+    )
 
-class ImageLeftAction(_ImageAction):  # pylint: disable=invalid-name
-    # pylint: disable=too-few-public-methods, unused-private-member
-    """
+    _all_wrapped_cxx_types = {*_py_template_params_to_cxx_type.values()}
+
+
+class ImageLeftAction(_ImageAction):
+    """TODO update
     Construct a ImageLeftAction instance.
 
     :Keyword Arguments:
@@ -114,7 +109,14 @@ class ImageLeftAction(_ImageAction):  # pylint: disable=invalid-name
 
     _py_template_params_to_cxx_type = {
         (_BMat8, _BMat8): _ImageLeftActionBMat8BMat8,
-        (PPerm, PPerm): {
-            (_PPerm1, _PPerm1): _ImageLeftActionPPerm1PPerm1,
-        },
+        (_PPerm1, _PPerm1): _ImageLeftActionPPerm1PPerm1,
     }
+
+    _cxx_type_to_py_template_params = dict(
+        zip(
+            _py_template_params_to_cxx_type.values(),
+            _py_template_params_to_cxx_type.keys(),
+        )
+    )
+
+    _all_wrapped_cxx_types = {*_py_template_params_to_cxx_type.values()}

libsemigroups_pybind11/detail/cxx_wrapper.py

@@ -277,6 +277,7 @@ def copy_cxx_mem_fns(cxx_class: pybind11_type, py_class: CxxWrapper) -> None:
 ########################################################################
 
 
+# TODO remove usage of this just call to_py_new directly
 def may_return_wrapped_cxx_obj(method):
     """
     Decorator for methods that might return a wrapped C++ object. If a wrapped
@@ -287,9 +288,6 @@ def may_return_wrapped_cxx_obj(method):
 
     @wraps(method)
     def wrapper(self, *args):
-        result = method(self, *args)
-        if type(result) in _CXX_WRAPPED_TYPE_TO_PY_TYPE:
-            return _CXX_WRAPPED_TYPE_TO_PY_TYPE[type(result)](result)
-        return result
+        return to_py_new(method(self, *args))
 
     return wrapper

src/action.cpp

@@ -468,6 +468,15 @@ Returns a Gabow object for strongly connected components.
 :rtype:
    Gabow
 )pbdoc");
+
+      thing.def(
+          "apply",
+          [](Action_ const&             self,
+             const_reference_point_type pt,
+             Element const&             x) { return self.apply(pt, x); },
+          R"pbdoc(
+                TODO
+)pbdoc");
     }  // bind_action
 
     template <typename Element, typename Point>

src/adapters.cpp

@@ -62,18 +62,30 @@ right action of the element *x*.
 .. doctest::
 
     >>> from libsemigroups_pybind11 import PPerm, ImageRightAction
-    >>> func = ImageRightAction(Point=PPerm, Element=PPerm)
     >>> x = PPerm([0, 1, 2, 3, 5, 6, 9], [9, 7, 3, 5, 4, 2, 1], 10)
     >>> pt = PPerm([0, 1, 2, 3, 5, 6], [0, 1, 2, 3, 5, 6], 10)
+    >>> func = ImageRightAction(point=pt, element=x)
     >>> func(pt, x)
     PPerm([2, 3, 4, 5, 7, 9], [2, 3, 4, 5, 7, 9], 10)
+    >>> func(_, x)
+    PPerm([1, 3, 4, 5], [1, 3, 4, 5], 10)
+    >>> func(_, x)
+    PPerm([4, 5, 7], [4, 5, 7], 10)
+    >>> func(_, x)
+    PPerm([4], [4], 10)
+    >>> func(_, x)
+    PPerm([], [], 10)
+    >>> func(_, x)
+    PPerm([], [], 10)
 )pbdoc")
           .def(py::init<>())
-          .def("__call__",
-               [](ImageRightAction_ const& self,
-                  Point&                   res,
-                  Point const&             pt,
-                  Element const&           x) -> void { self(res, pt, x); })
+          // The following doesn't yet work because mostly it's not possible to
+          // change <res> in place.
+          // .def("__call__",
+          //      [](ImageRightAction_ const& self,
+          //         Point&                   res,
+          //         Point const&             pt,
+          //         Element const&           x) -> void { self(res, pt, x); })
           .def("__call__",
                [](ImageRightAction_ const& self,
                   Point const&             pt,
@@ -88,7 +100,7 @@ right action of the element *x*.
     template <typename Element, typename Point>
     void bind_imageleftaction(py::module& m, std::string const& name) {
       using ImageLeftAction_ = ImageLeftAction<Element, Point>;
-      // TODO doc
+
       py::class_<ImageLeftAction_>(m,
                                    name.c_str(),
                                    R"pbdoc(
@@ -114,18 +126,20 @@ left action of the element *x*.
 .. doctest::
 
     >>> from libsemigroups_pybind11 import PPerm, ImageLeftAction
-    >>> func = ImageLeftAction(Point=PPerm, Element=PPerm)
     >>> x = PPerm([0, 1, 2, 3, 5, 6, 9], [9, 7, 3, 5, 4, 2, 1], 10)
     >>> pt = PPerm([0, 1, 2, 3, 5, 6], [0, 1, 2, 3, 5, 6], 10)
+    >>> func = ImageLeftAction(point=pt, element=x)
     >>> func(pt, x)
     PPerm([2, 3, 6, 9], [2, 3, 6, 9], 10)
 )pbdoc")
           .def(py::init<>())
-          .def("__call__",
-               [](ImageLeftAction_ const& self,
-                  Point&                  res,
-                  Point const&            pt,
-                  Element const&          x) { self(res, pt, x); })
+          // The following doesn't yet work because mostly it's not possible to
+          // change <res> in place.
+          //          .def("__call__",
+          //               [](ImageLeftAction_ const& self,
+          //                  Point&                  res,
+          //                  Point const&            pt,
+          //                  Element const&          x) { self(res, pt, x); })
           .def("__call__",
                [](ImageLeftAction_ const& self,
                   Point const&            pt,