MRO | The MHC Restriction Ontology | Genomics library

Good questions!

1. Because Square.__init__ accepts **kwargs we can actually pass whatever we want to it without getting an unexpected keyword argument error¹. This will become handy a bit later. Any keyword argument that it (and/or its superclasses' __init__ methods) does not consume will propagate up in the MRO until we get to object.

   
   ¹Usually. In this case the (unnecessery) call to

   super().__init__(**kwargs) in Triangle.__init__ breaks this behavior.

1. Due to the expansion of kwargs, when calling super().__init__(base, **kwargs) in Pyramid.__init__, Square.__init__ is actually called with (2, height=3, length=2). Since the argument of Square.__init__ is called length you recieve the error about multiple values for length.

2. That's correct. Furthermore, because nothing "consumed" the base keyword argument yet, Triangle.__init__ will receive it.

3. That's also correct. There is absolutely no need to call super().__init__(**kwargs) in Triangle.__init__, especially that by that point kwargs is an empty dict (all the keyword arguments it contained were consumed already).

ncap2 can work with attributes. However, you have a particularly thorny issue because your attribute name contains whitespace, and the attribute value is an array. I think in this case you need to first rename the attribute, then manipulate it. (Then you can rename it back if desired.):

The C3 linearization algorithm is somewhat depth-first, so A, being reachable from B (which is listed before C in the base class list) is added before C.

The rationale is that D is more "B-like" than "C-like", so anything that is part of "B" should appear before "C".

(For fun, see what happens if you try something like class D(B, A, C) when C still inherits from A.)

Edit: The question was edited to mention this approach while I was writing the answer.

You can do:

A child has a mother and a father and would best be designed to have mother and father attributes contained within. I think the following class definitions make more sense for your case:

This is what I meant by string manipulation, try this and see if it works:

You are testing the name to be an exact match in the $includes array using the -in operator, but that array contains wildcard characters, so will not work.

Instead, use the regex -match operator and set your $includes variable to be a string with partial names separated by the regex OR (|) character:

The problem with super(Integer, self).value.fset(self, _value) (or the simpler equivalent, super().value.fset(self, _value)) occurs before you even get to the fset. The descriptor protocol is engaged on all lookups on an instance, cause it to invoke the getter simply by doing super(Integer, self).value (or super().value). That's why your inherited getter works in the first place; it invoked the property descriptor, and got the value produced by it.

In order to bypass the descriptor protocol (more precisely, move from instance to class level invocation, where propertys do nothing special in the class level scenario), you need to perform the lookup on the class itself, not an instance of it. super(Integer, type(self)) invokes the form of super that returns a super object bound at the class level, not the instance level, allowing you to retrieve the raw descriptor itself, rather than invoking the descriptor and getting the value it produces. Once you have the raw descriptor, you can access and invoke the fset function attached to it.

This is the same issue you have when super isn't involved. If you have an instance of Number, and want to directly access the fset function (rather than invoking it implicitly via assignment), you have to do:

The self always refers to one and the same object. When you do super().__init__(), the self in the parent's __init__ is your instance of Child. GrandParent.__init__ just sets an attribute on that object. By chaining all those __init__s, you're in effect just doing this: