# What's happening here is the following: The ConditionalDispatch is just an # unbound callable object, that is, it does not know which class it is attached # to. What we do against that is return a wrapper and make that a classmethod - # thus we get the class as whose member it is called as as the first argument, # this is why in the type signature we always have type as the first type. # We then use run_cls, which just returns a wrapper that interprets the first # argument as the class the function should be called of. So, # x = run_cls("foo") returns something that turns x(cls, 1) into cls.foo(1). # Because this has *args, **kwargs as its signature we need to disable the # check of ConditionalDispatch that makes sure the function and the # conditional need to have the same signature - but they still do have to. LightCurve._cond_dispatch.add( run_cls("from_time"), lambda cls, time: is_time(time), # type is here because the class parameter is a class, # i.e. an instance of type (which is the base meta-class). [type, (basestring, datetime, tuple)], False, ) LightCurve._cond_dispatch.add( run_cls("from_range"), lambda cls, time1, time2, **kwargs: is_time(time1) and is_time(time2), [type, (basestring, datetime, tuple), (basestring, datetime, tuple)], False, ) LightCurve._cond_dispatch.add(
# What's happening here is the following: The ConditionalDispatch is just an # unbound callable object, that is, it does not know which class it is attached # to. What we do against that is return a wrapper and make that a classmethod - # thus we get the class as whose member it is called as as the first argument, # this is why in the type signature we always have type as the first type. # We then use run_cls, which just returns a wrapper that interprets the first # argument as the class the function should be called of. So, # x = run_cls("foo") returns something that turns x(cls, 1) into cls.foo(1). # Because this has *args, **kwargs as its signature we need to disable the # check of ConditionalDispatch that makes sure the function and the # conditional need to have the same signature - but they still do have to. LightCurve._cond_dispatch.add( run_cls("from_time"), lambda cls, time: sunpy.time.is_time(time), # type is here because the class parameter is a class, # i.e. an instance of type (which is the base meta-class). [type, (basestring, datetime, tuple)], False ) LightCurve._cond_dispatch.add( run_cls("from_range"), lambda cls, time, **kwargs: is_time(time), [type, (basestring, datetime, tuple)], False ) LightCurve._cond_dispatch.add(
# What's happening here is the following: The ConditionalDispatch is just an # unbound callable object, that is, it does not know which class it is attached # to. What we do against that is return a wrapper and make that a classmethod - # thus we get the class as whose member it is called as as the first argument, # this is why in the type signature we always have type as the first type. # We then use run_cls, which just returns a wrapper that interprets the first # argument as the class the function should be called of. So, # x = run_cls("foo") returns something that turns x(cls, 1) into cls.foo(1). # Because this has *args, **kwargs as its signature we need to disable the # check of ConditionalDispatch that makes sure the function and the # conditional need to have the same signature - but they still do have to. LightCurve._cond_dispatch.add( run_cls("from_time"), lambda cls, time, **kwargs: is_time(time), # type is here because the class parameter is a class, # i.e. an instance of type (which is the base meta-class). [type, (basestring, datetime, tuple)], False) LightCurve._cond_dispatch.add( run_cls("from_range"), lambda cls, time1, time2, **kwargs: is_time(time1) and is_time(time2), [type, (basestring, datetime, tuple), (basestring, datetime, tuple)], False) LightCurve._cond_dispatch.add(run_cls("from_timerange"), lambda cls, timerange, **kwargs: True, [type, TimeRange], False)
@classmethod def from_url(cls, url): """ Return object read from URL. Parameters ---------- url : str URL to retrieve the data from """ default_dir = sunpy.config.get("downloads", "download_dir") path = download_file(url, default_dir) return cls.read(path) Parent._create.add( run_cls('from_file'), lambda cls, filename: os.path.isfile(os.path.expanduser(filename)), [type, basestring], check=False ) Parent._create.add( # pylint: disable=W0108 # The lambda is necessary because introspection is peformed on the # argspec of the function. run_cls('from_dir'), lambda cls, directory: os.path.isdir(os.path.expanduser(directory)), [type, basestring], check=False ) # If it is not a kwarg and only one matches, do not return a list. Parent._create.add( run_cls('from_single_glob'), lambda cls, singlepattern: ('*' in singlepattern and
return CallistoSpectrogram.join_many([self, data], **kwargs) @classmethod def from_url(cls, url): """ Return CallistoSpectrogram read from URL. Parameters ---------- url : str URL to retrieve the data from """ return cls.read(url) CallistoSpectrogram._create.add( run_cls('from_range'), lambda cls, instrument, start, end: True, check=False ) CallistoSpectrogram.create.im_func.__doc__ = ( """ Create CallistoSpectrogram from given input dispatching to the appropriate from_* function. Possible signatures: """ + CallistoSpectrogram._create.generate_docs() ) if __name__ == "__main__": opn = CallistoSpectrogram.read("callisto/BIR_20110922_103000_01.fit")
data = data.clip_freq(self.freq_axis[-1], self.freq_axis[0]) return CallistoSpectrogram.join_many([self, data], **kwargs) @classmethod def from_url(cls, url): """ Return CallistoSpectrogram read from URL. Parameters ---------- url : str URL to retrieve the data from """ return cls.read(url) CallistoSpectrogram._create.add(run_cls("from_range"), lambda cls, instrument, start, end: True, check=False) CallistoSpectrogram.create.im_func.__doc__ = ( """ Create CallistoSpectrogram from given input dispatching to the appropriate from_* function. Possible signatures: """ + CallistoSpectrogram._create.generate_docs() ) if __name__ == "__main__": opn = CallistoSpectrogram.read("callisto/BIR_20110922_103000_01.fit") opn.subtract_bg().clip(0).plot(ratio=2).show() print "Press return to exit"
data = data.clip_freq(self.freq_axis[-1], self.freq_axis[0]) return CallistoSpectrogram.join_many([self, data], **kwargs) @classmethod def from_url(cls, url): """ Return CallistoSpectrogram read from URL. Parameters ---------- url : str URL to retrieve the data from """ return cls.read(url) CallistoSpectrogram._create.add(run_cls('from_range'), lambda cls, instrument, start, end: True, check=False) CallistoSpectrogram.create.im_func.__doc__ = ( """ Create CallistoSpectrogram from given input dispatching to the appropriate from_* function. Possible signatures: """ + CallistoSpectrogram._create.generate_docs()) if __name__ == "__main__": opn = CallistoSpectrogram.read("callisto/BIR_20110922_103000_01.fit") opn.subtract_bg().clip(0).plot(ratio=2).show() print "Press return to exit"
# What's happening here is the following: The ConditionalDispatch is just an # unbound callable object, that is, it does not know which class it is attached # to. What we do against that is return a wrapper and make that a classmethod - # thus we get the class as whose member it is called as as the first argument, # this is why in the type signature we always have type as the first type. # We then use run_cls, which just returns a wrapper that interprets the first # argument as the class the function should be called of. So, # x = run_cls("foo") returns something that turns x(cls, 1) into cls.foo(1). # Because this has *args, **kwargs as its signature we need to disable the # check of ConditionalDispatch that makes sure the function and the # conditional need to have the same signature - but they still do have to. LightCurve._cond_dispatch.add( run_cls("from_time"), lambda cls, time, **kwargs: is_time(time), # type is here because the class parameter is a class, # i.e. an instance of type (which is the base meta-class). [type, (six.string_types, datetime, tuple)], False ) LightCurve._cond_dispatch.add( run_cls("from_range"), lambda cls, time1, time2, **kwargs: is_time(time1) and is_time(time2), [type, (six.string_types, datetime, tuple), (six.string_types, datetime, tuple)], False )
@classmethod def from_url(cls, url): """ Return object read from URL. Parameters ---------- url : str URL to retrieve the data from """ path = download_file(url, get_and_create_download_dir()) return cls.read(path) Parent._create.add( run_cls('from_file'), lambda cls, filename: os.path.isfile(os.path.expanduser(filename)), [type, str], check=False) Parent._create.add( # pylint: disable=W0108 # The lambda is necessary because introspection is performed on the # argspec of the function. run_cls('from_dir'), lambda cls, directory: os.path.isdir(os.path.expanduser(directory)), [type, str], check=False) # If it is not a kwarg and only one matches, do not return a list. Parent._create.add(run_cls('from_single_glob'), lambda cls, singlepattern: ('*' in singlepattern and len( glob.glob(os.path.expanduser(singlepattern))) == 1),