ok so read full**.,..Python's operator precedence rules are designed to align with mathematical conventions. The (exponentiation) operator is given a higher precedence than other operators, allowing it to be evaluated first in an expression.... This decision follows the standard mathematical practice, ensuring consistency and order of operations. By evaluating exponentiation before other operations, Python maintains compatibility with mathematical notation and ensures correct results in expressions involving exponentiation. For operators with the same precedence (excluding **), Python follows the convention of evaluating them from left to right. This left-to-right evaluation maintains predictability and intuitive behavior when multiple operators of the same precedence are present in an expression. Overall, Python's operator precedence rules prioritize mathematical consistency and intuitive evaluation, enabling users to write expressions that adhere to established mathematical principles. More on reddit.com

So this is actually a really neat learning opportunity about how Ruby behaves. a + 2 is the same as a.send(:+, 2) (the conventional syntax is just syntactic sugar that hides that) You've addressed this by adding a def + to your custom class. The reverse: 2 + a is the same as 2.send(:+, a) This gets down to a C-defined method on the Integer primitive. If it is absolutely critical that you be able to do addition in either direction, you can refine the Integer primitive. class A def do_the_thing "This" end def +(a_number) "A receiving #{a_number}" end end module TheA refine Integer do def +(arg) super arg rescue TypeError raise unless arg.is_a?(A) "#{self} #{arg.do_the_thing}" end end end # This incorporates the module into the current scope, # allowing access to the Integer refinement. It also prevents the # refinement from being implicitly applied globally. using TheA a = A.new => # puts a + 2 => "A receiving 2" puts 2 + a => "2 This" This is kind of danger territory. Refinements are a little better than monkey-patching, but it's one of the many examples of Ruby being very permissive and always willing to pour you another whether or not it's good for you. It would be a lot safer to use non-syntactic-sugar methods for the primary behavior, and add syntactic-sugar methods as conveniences. (so :add or :append instead of :+). Remember that in Ruby, it's all about passing messages to objects. Commutative behavior is never presumed. 1 + 2 is the same as 1.send(:+, 2) and 2 + 1 is the same as 2.send(:+, 1) "foo".upcase.reverse is the same as "foo".send(:upcase).send(:reverse) this works because both of those methods returns a String, and String knows how to respond to both methods. "foo" * 2 is the same as "foo".send(:*, 2) (it outputs "foofoo"), but 2 * "foo" gives a TypeError. On the other hand, "foo".size * 2 [ "foo".send(:size).send(:*, 2) ] is the same as 2 * "foo".size [ 2.send(:*, "foo".send(:size) ) ] because foo.size returns an Integer. You want the thing on the left of the "." to be able to respond to the message it's receiving on the right. You control the class that instantiated a, so you should ensure that that class is what is handling the :+ message in your code, if at all possible. More on reddit.com

Really only the second condition matters. You can use a negative lookbehind group to accomplish it: (? More on reddit.com

As a best practice, you should avoid using compute on the Airflow server. The most common approach is to offload to k8s pods. The additional complexity is managing the image that k8s will need to run. More on reddit.com