Is there a way to += and -= of an attribute call a instance's method?

Question

Question: Is there a way to (+= and -=) call (insert_knot and remove_knot) in the class bellow?

EDIT: It's not duplicated from this question, cause I'm changing an attribute of the class (summing and subtracting), not the instance by itself. I mean, I sum/subtract an attribute and a method of the instance should be called.

class SplineCurve:
    def __init__(self, knot_vector: Tuple[float]):
        self.knot_vector = knot_vector

    @property
    def degree(self) -> int:
        return self.__degree

    @property
    def knot_vector(self) -> Tuple[float]:
        return tuple(self.__knot_vector)

    @degree.setter
    def degree(self, new_value: int):
        if new_value == self.degree:
            return
        if new_value > self.degree:
            self.increase_degree(new_value - self.degree)
        else:
            self.decrease_degree(self.degree - new_value)
        self.__degree = new_value

    @knot_vector.setter
    def knot_vector(self, new_value: Tuple[float]):
        new_value = list(new_value)
        new_value.sort()  # Shouldn't be here, only in 'insert_knot'
        self.__knot_vector = tuple(new_value)
            
    def increase_degree(self, times: int):
        self.compute_ctrl_points()

    def decrease_degree(self, times: int):
        self.compute_ctrl_points()

    def insert_knot(self, knots: Tuple[float]):
        print(f"Inserting knots {knots}")
        new_knot_vector = list(self.knot_vector)
        for knot in knots:
            new_knot_vector += [knot]
        new_knot_vector.sort()
        self.knot_vector = new_knot_vector
        self.compute_ctrl_points()

    def remove_knot(self, knots: Tuple[float]):
        print(f"Removing knots {knots}")
        new_knot_vector = list(self.knot_vector)
        for knot in knots:
            new_knot_vector.remove(knot)
        self.knot_vector = new_knot_vector
        self.compute_ctrl_points()

    def compute_ctrl_points(self):
        print("I must be called on insertion and remotion")

Then I want to the user do it:

mycurve = SplineCurve([0, 0, 1, 1])
print(mycurve.knot_vector)         # (0, 0, 1, 1)
mycurve.knot_vector += (0.5, 0.5)  # This line should called as 'mycurve.insert_knot((0.5, 0.5))'
print(mycurve.knot_vector)         # (0, 0, 0.5, 0.5, 1, 1)
mycurve.knot_vector -= (0.5, 1)    # This line should called as 'mycurve.remove_knot((0.5, 1))'
print(mycurve.knot_vector)         # (0, 0, 0.5, 1)

For inserting knot, the printed value is correct, but the function insert_knot (and Inserting knots ... is not printed).

But for -= gives the error TypeError: unsupported operand type(s) for -=: 'tuple' and 'tuple', which is normal, cause it's like

temp_value = mycurve.knot_vector - (0.5, 1)  # Error here
mycurve.knot_vector = temp_value  # Setter is only called here

Calling the argument on insert_knot and remove_knot should allow also:

mycurve.knot_vector += numpy.array([0.3, 0.7])
mycurve.knot_vector += [0.4, 0.9]

You would need to overload the `+=` operator on the object returned by `knot_vector`. This means that it needs to be a user-defined object and not a tuple. — interjay, Dec 04 '22 at 15:23
@interjay Doing it, it will only change the values of ```knot_vector``` object. If ```insert_knot``` changes something in ```mycurve```(like calling ```compute_ctrl_points```), it won't happen. — Carlos Adir, Dec 04 '22 at 15:29
It seems very confusing and error-prone if `x.knot_vector += y` changes things which aren't in `knot_vector`. But if you really want then you can put a reference to the containing object in the `knot_vector` object and then call `insert_knot` on that. — interjay, Dec 04 '22 at 15:33
@interjay Yes, I agree with you at the point ```x.knot_vector += y``` changes something in ```x``` may be confusing, but I did the same for ```degree``` and it seems very nice. The difference would be only the type (```degree``` is an integer, while ```knot_vector``` is an array of floats). Both concepts (```degree``` and ```knot_vector```) exist only if the curve exists. — Carlos Adir, Dec 04 '22 at 15:47

score 0 · Accepted Answer · answered Dec 11 '22 at 23:20

The solution as proposed @interjay is to create a new class object that can sum with an iterable.

Then there's two possibilities:

Call the curve.insert_knot on __iadd__ and curve.remove_knot on __isub__ using indirect reference, and then lose the curve's reference. We can return None and curve.knot_vector setter does nothing.

class KnotVector(Tuple):
    def __new__(cls, curve, args: tuple[float]):
        self = super(KnotVector, cls).__new__(cls, tuple(args))
        self._curve = curve
        return self
    
    def __iadd__(self, knots: tuple[float]):
        if self._curve is not None:
            self._curve.insert_knot(knots)
            self._curve = None
        else:
            return tuple(self) + knots

    def __isub__(self, knots: tuple[float]):
        if self._curve is not None:
            self._curve.remove_knot(knots)
            self._curve = None
        else:
            return tuple(self) + knots

class SplineCurve:
    ...
    @property
    def knot_vector(self) -> KnotVector:
        return KnotVector(self, tuple(self._knot_vector))

    @knot_vector.setter
    def knot_vector(self, new_knot_vector: Tuple[float]):
        if new_value is None:
            return
        self._knot_vector = tuple(new_knot_vector)
    ...

A problem that can happen is assigning knot_vector into a variable myvector, and then it changes mycurve without noticing.

mycurve = SplineCurve([0, 0, 1, 1])
myvector = mycurve.knot_vector
# ... after many instructions
myvector += (0.5, 0.5)  # This will change mycurve

Modify in KnotVector class to add and remove, and give the information to mycurve through knot_vector setter, the same way that happens for degree:

class KnotVector(Tuple):
    def __new__(cls, args: tuple[float]):
        return super(KnotVector, cls).__new__(cls, tuple(args))
    
    def __iadd__(self, knots: tuple[float]):
        new_knot_vector = list(self)
        for knot in knots:
            new_knot_vector += [knot]
        new_knot_vector.sort()
        return tuple(new_knot_vector)

    def __isub__(self, knots: tuple[float]):
        new_knot_vector = list(self)
        for knot in knots:
            new_knot_vector.remove(knot)
        return tuple(new_knot_vector)

class SplineCurve:
    ...

    @property
    def knot_vector(self) -> KnotVector:
        return KnotVector(self._knot_vector)

    @knot_vector.setter
    def knot_vector(self, new_knot_vector: Tuple[float]):
        if self._knot_vector == new_knot_vector:
            return
        if self.new_knots_inserted(new_knot_vector):
            self.insert_knot(self.get_new_knots(new_knot_vector))
        else:
            self.remove_knot(self.get_removed_knots(new_knot_vector))
    ...

Is there a way to += and -= of an attribute call a instance's method?

1 Answers1