give resolution time in minutes for the given user story, only provide the number of minutes in the output without any other text

User story: As posted to lsst-data:  I see this pattern in our code:  {code:py} class FooTask(Task):    def __init__(self, whatever):        Task.__init__(self, whatever)        self.metadata.add("task", "foo") {code}  (and similarly for other methods, and other classes such as {{Config}}).  I would like to encourage people not to write {{Task.\_\_init\_\_}}, but write instead {{super(FooTask, self).\_\_init\_\_}} (and similarly for other methods, and other classes).  I understand that this is longer and the repetition of the class name opens possible maintenance problems (e.g., changing the name of the class).  The reason for using {{super}} is that it makes multiple inheritance easier and, in some cases it is required to make it operate properly.  For example, consider that I now want to make a version of {{FooTask}} that has some extra function (inherits from {{ExtraFunctionTask}}):  {code:py} class ExtraFunctionFooTask(ExtraFunctionTask, FooTask):    def __init__(self, whatever):        # ??? {code}  The question is, what should {{ExtraFunctionFooTask.\_\_init\_\_}} call?  Well, if it explicitly calls the {{\_\_init\_\_}} methods of the two parent classes, then it ends up calling {{Task.\_\_init\_\_}} twice, which can lead to trouble if, e.g., one of the parent classes modifies a value initialised by {{Task.\_\_init\_\_}}:  {code:py} class ExtraFunctionTask(Task):    def __init__(self, whatever):        Task.__init__(self, whatever)        self.metadata.add("task", "extraFunction") {code}  so calling {{ExtraFunctionTask.\_\_init\_\_}} followed by {{FooTask.\_\_init\_\_}} (or the other way around) would result in a {{self.metadata}} containing only one element (because {{Task.\_\_init\_\_}} initialises {{self.metadata}}).  This is a simple, contrived example, but it serves to illustrate the general problem.  Python provides super for this reason --- calls to {{super()}} march along the "Method Resolution Order", so that each parent class' method is only called once (see https://www.python.org/download/releases/2.3/mro/).  The problem is, if you're going to use super at all, then all parent classes need to use super (otherwise the chain gets interrupted).  I suggest that this is the Pythonic way of referring to the super class, and failure to use it may unnecessarily limit the use of our code.  Common objections:  * I've heard that {{super}} should be considered harmful (https://fuhm.net/super-harmful/) ==> The objections raised here basically boil down to "use {{super}} always or not at all", and "you need to be careful/disciplined".  * It's harder to read / it's not clear ==> Yes, it's annoying that you have to repeat the name of your class (which can also lead to maintenance problems if you change the name of the class), but that's an unfortunate limitation of our language of choice (python 2; it's fixed in python 3).  Nevertheless, it's the pattern provided by the language, so it's arguably idiomatic, and therefore should be readily recognisable by all python programmers.  I suggest that it will become clearer and easier to read as we become more practised using it.  * There are some weird corner-case issues with it ==> {{super}} doesn't always resolve to the super-class of the class that's calling {{super()}}.  In fact, this is a feature (in the example above, it's why {{Task.\_\_init\_\_}} doesn't get called twice).  This should only be a problem when debugging objects with multiple inheritance, and it is solved by understanding the MRO. You can always look at the {{\_\_mro\_\_}} attribute of your object.  * It only matters with multiple inheritance ==> Kinda.  It only matters if someone wants to use multiple inheritance using something we've written.  But as I've demonstrated above, choices made low in the hierarchy level (e.g., how {{FooTask}} calls the super class) affects the ability of higher-level components to effectively use multiple inheritance.  If someone wants to use our classes in a multiple inheritance (and I do) and we haven't used super, then we're preventing them from making use of our code.  For the sake of users of our code who want to use multiple inheritance, please consider mandating the use of super.
Answer: 243010.0