repository_name
stringlengths 7
55
| func_path_in_repository
stringlengths 4
223
| func_name
stringlengths 1
134
| whole_func_string
stringlengths 75
104k
| language
stringclasses 1
value | func_code_string
stringlengths 75
104k
| func_code_tokens
listlengths 19
28.4k
| func_documentation_string
stringlengths 1
46.9k
| func_documentation_tokens
listlengths 1
1.97k
| split_name
stringclasses 1
value | func_code_url
stringlengths 87
315
|
|---|---|---|---|---|---|---|---|---|---|---|
spacetelescope/synphot_refactor
|
synphot/observation.py
|
Observation.plot
|
def plot(self, binned=True, wavelengths=None, flux_unit=None, area=None,
vegaspec=None, **kwargs): # pragma: no cover
"""Plot the observation.
.. note:: Uses ``matplotlib``.
Parameters
----------
binned : bool
Plot data in native wavelengths if `False`.
Else, plot binned data (default).
wavelengths : array-like, `~astropy.units.quantity.Quantity`, or `None`
Wavelength values for sampling.
If not a Quantity, assumed to be in Angstrom.
If `None`, ``self.waveset`` or `binset` is used, depending
on ``binned``.
flux_unit : str or `~astropy.units.core.Unit` or `None`
Flux is converted to this unit for plotting.
If not given, internal unit is used.
area, vegaspec
See :func:`~synphot.units.convert_flux`.
kwargs : dict
See :func:`synphot.spectrum.BaseSpectrum.plot`.
Raises
------
synphot.exceptions.SynphotError
Invalid inputs.
"""
if binned:
w, y = self._get_binned_arrays(wavelengths, flux_unit, area=area,
vegaspec=vegaspec)
else:
w, y = self._get_arrays(wavelengths, flux_unit=flux_unit,
area=area, vegaspec=vegaspec)
self._do_plot(w, y, **kwargs)
|
python
|
def plot(self, binned=True, wavelengths=None, flux_unit=None, area=None,
vegaspec=None, **kwargs): # pragma: no cover
"""Plot the observation.
.. note:: Uses ``matplotlib``.
Parameters
----------
binned : bool
Plot data in native wavelengths if `False`.
Else, plot binned data (default).
wavelengths : array-like, `~astropy.units.quantity.Quantity`, or `None`
Wavelength values for sampling.
If not a Quantity, assumed to be in Angstrom.
If `None`, ``self.waveset`` or `binset` is used, depending
on ``binned``.
flux_unit : str or `~astropy.units.core.Unit` or `None`
Flux is converted to this unit for plotting.
If not given, internal unit is used.
area, vegaspec
See :func:`~synphot.units.convert_flux`.
kwargs : dict
See :func:`synphot.spectrum.BaseSpectrum.plot`.
Raises
------
synphot.exceptions.SynphotError
Invalid inputs.
"""
if binned:
w, y = self._get_binned_arrays(wavelengths, flux_unit, area=area,
vegaspec=vegaspec)
else:
w, y = self._get_arrays(wavelengths, flux_unit=flux_unit,
area=area, vegaspec=vegaspec)
self._do_plot(w, y, **kwargs)
|
[
"def",
"plot",
"(",
"self",
",",
"binned",
"=",
"True",
",",
"wavelengths",
"=",
"None",
",",
"flux_unit",
"=",
"None",
",",
"area",
"=",
"None",
",",
"vegaspec",
"=",
"None",
",",
"*",
"*",
"kwargs",
")",
":",
"# pragma: no cover",
"if",
"binned",
":",
"w",
",",
"y",
"=",
"self",
".",
"_get_binned_arrays",
"(",
"wavelengths",
",",
"flux_unit",
",",
"area",
"=",
"area",
",",
"vegaspec",
"=",
"vegaspec",
")",
"else",
":",
"w",
",",
"y",
"=",
"self",
".",
"_get_arrays",
"(",
"wavelengths",
",",
"flux_unit",
"=",
"flux_unit",
",",
"area",
"=",
"area",
",",
"vegaspec",
"=",
"vegaspec",
")",
"self",
".",
"_do_plot",
"(",
"w",
",",
"y",
",",
"*",
"*",
"kwargs",
")"
] |
Plot the observation.
.. note:: Uses ``matplotlib``.
Parameters
----------
binned : bool
Plot data in native wavelengths if `False`.
Else, plot binned data (default).
wavelengths : array-like, `~astropy.units.quantity.Quantity`, or `None`
Wavelength values for sampling.
If not a Quantity, assumed to be in Angstrom.
If `None`, ``self.waveset`` or `binset` is used, depending
on ``binned``.
flux_unit : str or `~astropy.units.core.Unit` or `None`
Flux is converted to this unit for plotting.
If not given, internal unit is used.
area, vegaspec
See :func:`~synphot.units.convert_flux`.
kwargs : dict
See :func:`synphot.spectrum.BaseSpectrum.plot`.
Raises
------
synphot.exceptions.SynphotError
Invalid inputs.
|
[
"Plot",
"the",
"observation",
"."
] |
train
|
https://github.com/spacetelescope/synphot_refactor/blob/9c064f3cff0c41dd8acadc0f67c6350931275b9f/synphot/observation.py#L616-L656
|
spacetelescope/synphot_refactor
|
synphot/observation.py
|
Observation.as_spectrum
|
def as_spectrum(self, binned=True, wavelengths=None):
"""Reduce the observation to an empirical source spectrum.
An observation is a complex object with some restrictions
on its capabilities. At times, it would be useful to work
with the observation as a simple object that is easier to
manipulate and takes up less memory.
This is also useful for writing an observation as sampled
spectrum out to a FITS file.
Parameters
----------
binned : bool
Write out data in native wavelengths if `False`.
Else, write binned data (default).
wavelengths : array-like, `~astropy.units.quantity.Quantity`, or `None`
Wavelength values for sampling.
If not a Quantity, assumed to be in Angstrom.
If `None`, ``self.waveset`` or `binset` is used, depending
on ``binned``.
Returns
-------
sp : `~synphot.spectrum.SourceSpectrum`
Empirical source spectrum.
"""
if binned:
w, y = self._get_binned_arrays(
wavelengths, self._internal_flux_unit)
else:
w, y = self._get_arrays(
wavelengths, flux_unit=self._internal_flux_unit)
header = {'observation': str(self), 'binned': binned}
return SourceSpectrum(Empirical1D, points=w, lookup_table=y,
meta={'header': header})
|
python
|
def as_spectrum(self, binned=True, wavelengths=None):
"""Reduce the observation to an empirical source spectrum.
An observation is a complex object with some restrictions
on its capabilities. At times, it would be useful to work
with the observation as a simple object that is easier to
manipulate and takes up less memory.
This is also useful for writing an observation as sampled
spectrum out to a FITS file.
Parameters
----------
binned : bool
Write out data in native wavelengths if `False`.
Else, write binned data (default).
wavelengths : array-like, `~astropy.units.quantity.Quantity`, or `None`
Wavelength values for sampling.
If not a Quantity, assumed to be in Angstrom.
If `None`, ``self.waveset`` or `binset` is used, depending
on ``binned``.
Returns
-------
sp : `~synphot.spectrum.SourceSpectrum`
Empirical source spectrum.
"""
if binned:
w, y = self._get_binned_arrays(
wavelengths, self._internal_flux_unit)
else:
w, y = self._get_arrays(
wavelengths, flux_unit=self._internal_flux_unit)
header = {'observation': str(self), 'binned': binned}
return SourceSpectrum(Empirical1D, points=w, lookup_table=y,
meta={'header': header})
|
[
"def",
"as_spectrum",
"(",
"self",
",",
"binned",
"=",
"True",
",",
"wavelengths",
"=",
"None",
")",
":",
"if",
"binned",
":",
"w",
",",
"y",
"=",
"self",
".",
"_get_binned_arrays",
"(",
"wavelengths",
",",
"self",
".",
"_internal_flux_unit",
")",
"else",
":",
"w",
",",
"y",
"=",
"self",
".",
"_get_arrays",
"(",
"wavelengths",
",",
"flux_unit",
"=",
"self",
".",
"_internal_flux_unit",
")",
"header",
"=",
"{",
"'observation'",
":",
"str",
"(",
"self",
")",
",",
"'binned'",
":",
"binned",
"}",
"return",
"SourceSpectrum",
"(",
"Empirical1D",
",",
"points",
"=",
"w",
",",
"lookup_table",
"=",
"y",
",",
"meta",
"=",
"{",
"'header'",
":",
"header",
"}",
")"
] |
Reduce the observation to an empirical source spectrum.
An observation is a complex object with some restrictions
on its capabilities. At times, it would be useful to work
with the observation as a simple object that is easier to
manipulate and takes up less memory.
This is also useful for writing an observation as sampled
spectrum out to a FITS file.
Parameters
----------
binned : bool
Write out data in native wavelengths if `False`.
Else, write binned data (default).
wavelengths : array-like, `~astropy.units.quantity.Quantity`, or `None`
Wavelength values for sampling.
If not a Quantity, assumed to be in Angstrom.
If `None`, ``self.waveset`` or `binset` is used, depending
on ``binned``.
Returns
-------
sp : `~synphot.spectrum.SourceSpectrum`
Empirical source spectrum.
|
[
"Reduce",
"the",
"observation",
"to",
"an",
"empirical",
"source",
"spectrum",
"."
] |
train
|
https://github.com/spacetelescope/synphot_refactor/blob/9c064f3cff0c41dd8acadc0f67c6350931275b9f/synphot/observation.py#L658-L696
|
Julius2342/pyvlx
|
pyvlx/set_node_name.py
|
SetNodeName.handle_frame
|
async def handle_frame(self, frame):
"""Handle incoming API frame, return True if this was the expected frame."""
if not isinstance(frame, FrameSetNodeNameConfirmation):
return False
self.success = frame.status == SetNodeNameConfirmationStatus.OK
return True
|
python
|
async def handle_frame(self, frame):
"""Handle incoming API frame, return True if this was the expected frame."""
if not isinstance(frame, FrameSetNodeNameConfirmation):
return False
self.success = frame.status == SetNodeNameConfirmationStatus.OK
return True
|
[
"async",
"def",
"handle_frame",
"(",
"self",
",",
"frame",
")",
":",
"if",
"not",
"isinstance",
"(",
"frame",
",",
"FrameSetNodeNameConfirmation",
")",
":",
"return",
"False",
"self",
".",
"success",
"=",
"frame",
".",
"status",
"==",
"SetNodeNameConfirmationStatus",
".",
"OK",
"return",
"True"
] |
Handle incoming API frame, return True if this was the expected frame.
|
[
"Handle",
"incoming",
"API",
"frame",
"return",
"True",
"if",
"this",
"was",
"the",
"expected",
"frame",
"."
] |
train
|
https://github.com/Julius2342/pyvlx/blob/ee78e1324bcb1be5b8d1a9d05ab5496b72eae848/pyvlx/set_node_name.py#L18-L23
|
Julius2342/pyvlx
|
pyvlx/api_event.py
|
ApiEvent.do_api_call
|
async def do_api_call(self):
"""Start. Sending and waiting for answer."""
self.pyvlx.connection.register_frame_received_cb(
self.response_rec_callback)
await self.send_frame()
await self.start_timeout()
await self.response_received_or_timeout.wait()
await self.stop_timeout()
self.pyvlx.connection.unregister_frame_received_cb(self.response_rec_callback)
|
python
|
async def do_api_call(self):
"""Start. Sending and waiting for answer."""
self.pyvlx.connection.register_frame_received_cb(
self.response_rec_callback)
await self.send_frame()
await self.start_timeout()
await self.response_received_or_timeout.wait()
await self.stop_timeout()
self.pyvlx.connection.unregister_frame_received_cb(self.response_rec_callback)
|
[
"async",
"def",
"do_api_call",
"(",
"self",
")",
":",
"self",
".",
"pyvlx",
".",
"connection",
".",
"register_frame_received_cb",
"(",
"self",
".",
"response_rec_callback",
")",
"await",
"self",
".",
"send_frame",
"(",
")",
"await",
"self",
".",
"start_timeout",
"(",
")",
"await",
"self",
".",
"response_received_or_timeout",
".",
"wait",
"(",
")",
"await",
"self",
".",
"stop_timeout",
"(",
")",
"self",
".",
"pyvlx",
".",
"connection",
".",
"unregister_frame_received_cb",
"(",
"self",
".",
"response_rec_callback",
")"
] |
Start. Sending and waiting for answer.
|
[
"Start",
".",
"Sending",
"and",
"waiting",
"for",
"answer",
"."
] |
train
|
https://github.com/Julius2342/pyvlx/blob/ee78e1324bcb1be5b8d1a9d05ab5496b72eae848/pyvlx/api_event.py#L18-L26
|
Julius2342/pyvlx
|
pyvlx/api_event.py
|
ApiEvent.start_timeout
|
async def start_timeout(self):
"""Start timeout."""
self.timeout_handle = self.pyvlx.connection.loop.call_later(
self.timeout_in_seconds, self.timeout)
|
python
|
async def start_timeout(self):
"""Start timeout."""
self.timeout_handle = self.pyvlx.connection.loop.call_later(
self.timeout_in_seconds, self.timeout)
|
[
"async",
"def",
"start_timeout",
"(",
"self",
")",
":",
"self",
".",
"timeout_handle",
"=",
"self",
".",
"pyvlx",
".",
"connection",
".",
"loop",
".",
"call_later",
"(",
"self",
".",
"timeout_in_seconds",
",",
"self",
".",
"timeout",
")"
] |
Start timeout.
|
[
"Start",
"timeout",
"."
] |
train
|
https://github.com/Julius2342/pyvlx/blob/ee78e1324bcb1be5b8d1a9d05ab5496b72eae848/pyvlx/api_event.py#L49-L52
|
Julius2342/pyvlx
|
old_api/examples/example.py
|
main
|
async def main():
"""Load devices and scenes, run first scene."""
pyvlx = PyVLX('pyvlx.yaml')
# Alternative:
# pyvlx = PyVLX(host="192.168.2.127", password="velux123", timeout=60)
await pyvlx.load_devices()
print(pyvlx.devices[1])
print(pyvlx.devices['Fenster 4'])
await pyvlx.load_scenes()
print(pyvlx.scenes[0])
print(pyvlx.scenes['Bath Closed'])
# opening/ closing windows by running scenes, yay!
await pyvlx.scenes[1].run()
await pyvlx.disconnect()
|
python
|
async def main():
"""Load devices and scenes, run first scene."""
pyvlx = PyVLX('pyvlx.yaml')
# Alternative:
# pyvlx = PyVLX(host="192.168.2.127", password="velux123", timeout=60)
await pyvlx.load_devices()
print(pyvlx.devices[1])
print(pyvlx.devices['Fenster 4'])
await pyvlx.load_scenes()
print(pyvlx.scenes[0])
print(pyvlx.scenes['Bath Closed'])
# opening/ closing windows by running scenes, yay!
await pyvlx.scenes[1].run()
await pyvlx.disconnect()
|
[
"async",
"def",
"main",
"(",
")",
":",
"pyvlx",
"=",
"PyVLX",
"(",
"'pyvlx.yaml'",
")",
"# Alternative:",
"# pyvlx = PyVLX(host=\"192.168.2.127\", password=\"velux123\", timeout=60)",
"await",
"pyvlx",
".",
"load_devices",
"(",
")",
"print",
"(",
"pyvlx",
".",
"devices",
"[",
"1",
"]",
")",
"print",
"(",
"pyvlx",
".",
"devices",
"[",
"'Fenster 4'",
"]",
")",
"await",
"pyvlx",
".",
"load_scenes",
"(",
")",
"print",
"(",
"pyvlx",
".",
"scenes",
"[",
"0",
"]",
")",
"print",
"(",
"pyvlx",
".",
"scenes",
"[",
"'Bath Closed'",
"]",
")",
"# opening/ closing windows by running scenes, yay!",
"await",
"pyvlx",
".",
"scenes",
"[",
"1",
"]",
".",
"run",
"(",
")",
"await",
"pyvlx",
".",
"disconnect",
"(",
")"
] |
Load devices and scenes, run first scene.
|
[
"Load",
"devices",
"and",
"scenes",
"run",
"first",
"scene",
"."
] |
train
|
https://github.com/Julius2342/pyvlx/blob/ee78e1324bcb1be5b8d1a9d05ab5496b72eae848/old_api/examples/example.py#L6-L23
|
Julius2342/pyvlx
|
pyvlx/on_off_switch.py
|
OnOffSwitch.set_state
|
async def set_state(self, parameter):
"""Set switch to desired state."""
command_send = CommandSend(pyvlx=self.pyvlx, node_id=self.node_id, parameter=parameter)
await command_send.do_api_call()
if not command_send.success:
raise PyVLXException("Unable to send command")
self.parameter = parameter
await self.after_update()
|
python
|
async def set_state(self, parameter):
"""Set switch to desired state."""
command_send = CommandSend(pyvlx=self.pyvlx, node_id=self.node_id, parameter=parameter)
await command_send.do_api_call()
if not command_send.success:
raise PyVLXException("Unable to send command")
self.parameter = parameter
await self.after_update()
|
[
"async",
"def",
"set_state",
"(",
"self",
",",
"parameter",
")",
":",
"command_send",
"=",
"CommandSend",
"(",
"pyvlx",
"=",
"self",
".",
"pyvlx",
",",
"node_id",
"=",
"self",
".",
"node_id",
",",
"parameter",
"=",
"parameter",
")",
"await",
"command_send",
".",
"do_api_call",
"(",
")",
"if",
"not",
"command_send",
".",
"success",
":",
"raise",
"PyVLXException",
"(",
"\"Unable to send command\"",
")",
"self",
".",
"parameter",
"=",
"parameter",
"await",
"self",
".",
"after_update",
"(",
")"
] |
Set switch to desired state.
|
[
"Set",
"switch",
"to",
"desired",
"state",
"."
] |
train
|
https://github.com/Julius2342/pyvlx/blob/ee78e1324bcb1be5b8d1a9d05ab5496b72eae848/pyvlx/on_off_switch.py#L16-L23
|
spacetelescope/synphot_refactor
|
synphot/reddening.py
|
etau_madau
|
def etau_madau(wave, z, **kwargs):
"""Madau 1995 extinction for a galaxy at given redshift.
This is the Lyman-alpha prescription from the photo-z code BPZ.
The Lyman-alpha forest approximately has an effective
"throughput" which is a function of redshift and
rest-frame wavelength.
One would multiply the SEDs by this factor before
passing it through an instrument filter.
This approximation is from Footnote 3 of
:ref:`Madau et al. (1995) <synphot-ref-madau1995>`.
This is claimed accurate to 5%.
The scatter in this factor (due to different lines of sight)
is huge, as shown in Madau's Fig. 3 (top panel);
The figure's bottom panel shows a redshifted version of the
"exact" prescription.
Parameters
----------
wave : array-like or `~astropy.units.quantity.Quantity`
Redshifted wavelength values.
Non-redshifted wavelength is ``wave / (1 + z)``.
z : number
Redshift.
kwargs : dict
Equivalencies for unit conversion, see
:func:`~synphot.units.validate_quantity`.
Returns
-------
extcurve : `ExtinctionCurve`
Extinction curve to apply to the redshifted spectrum.
"""
if not isinstance(z, numbers.Real):
raise exceptions.SynphotError(
'Redshift must be a real scalar number.')
if np.isscalar(wave) or len(wave) <= 1:
raise exceptions.SynphotError('Wavelength has too few data points')
wave = units.validate_quantity(wave, u.AA, **kwargs).value
ll = 912.0
c = np.array([3.6e-3, 1.7e-3, 1.2e-3, 9.3e-4])
el = np.array([1216, 1026, 973, 950], dtype=np.float) # noqa
tau = np.zeros_like(wave, dtype=np.float)
xe = 1.0 + z
# Lyman series
for i in range(len(el)):
tau = np.where(wave <= el[i] * xe,
tau + c[i] * (wave / el[i]) ** 3.46,
tau)
# Photoelectric absorption
xc = wave / ll
xc3 = xc ** 3
tau = np.where(wave <= ll * xe,
(tau + 0.25 * xc3 * (xe ** 0.46 - xc ** 0.46) +
9.4 * xc ** 1.5 * (xe ** 0.18 - xc ** 0.18) -
0.7 * xc3 * (xc ** (-1.32) - xe ** (-1.32)) -
0.023 * (xe ** 1.68 - xc ** 1.68)),
tau)
thru = np.where(tau > 700., 0., np.exp(-tau))
meta = {'descrip': 'Madau 1995 extinction for z={0}'.format(z)}
return ExtinctionCurve(ExtinctionModel1D, points=wave, lookup_table=thru,
meta=meta)
|
python
|
def etau_madau(wave, z, **kwargs):
"""Madau 1995 extinction for a galaxy at given redshift.
This is the Lyman-alpha prescription from the photo-z code BPZ.
The Lyman-alpha forest approximately has an effective
"throughput" which is a function of redshift and
rest-frame wavelength.
One would multiply the SEDs by this factor before
passing it through an instrument filter.
This approximation is from Footnote 3 of
:ref:`Madau et al. (1995) <synphot-ref-madau1995>`.
This is claimed accurate to 5%.
The scatter in this factor (due to different lines of sight)
is huge, as shown in Madau's Fig. 3 (top panel);
The figure's bottom panel shows a redshifted version of the
"exact" prescription.
Parameters
----------
wave : array-like or `~astropy.units.quantity.Quantity`
Redshifted wavelength values.
Non-redshifted wavelength is ``wave / (1 + z)``.
z : number
Redshift.
kwargs : dict
Equivalencies for unit conversion, see
:func:`~synphot.units.validate_quantity`.
Returns
-------
extcurve : `ExtinctionCurve`
Extinction curve to apply to the redshifted spectrum.
"""
if not isinstance(z, numbers.Real):
raise exceptions.SynphotError(
'Redshift must be a real scalar number.')
if np.isscalar(wave) or len(wave) <= 1:
raise exceptions.SynphotError('Wavelength has too few data points')
wave = units.validate_quantity(wave, u.AA, **kwargs).value
ll = 912.0
c = np.array([3.6e-3, 1.7e-3, 1.2e-3, 9.3e-4])
el = np.array([1216, 1026, 973, 950], dtype=np.float) # noqa
tau = np.zeros_like(wave, dtype=np.float)
xe = 1.0 + z
# Lyman series
for i in range(len(el)):
tau = np.where(wave <= el[i] * xe,
tau + c[i] * (wave / el[i]) ** 3.46,
tau)
# Photoelectric absorption
xc = wave / ll
xc3 = xc ** 3
tau = np.where(wave <= ll * xe,
(tau + 0.25 * xc3 * (xe ** 0.46 - xc ** 0.46) +
9.4 * xc ** 1.5 * (xe ** 0.18 - xc ** 0.18) -
0.7 * xc3 * (xc ** (-1.32) - xe ** (-1.32)) -
0.023 * (xe ** 1.68 - xc ** 1.68)),
tau)
thru = np.where(tau > 700., 0., np.exp(-tau))
meta = {'descrip': 'Madau 1995 extinction for z={0}'.format(z)}
return ExtinctionCurve(ExtinctionModel1D, points=wave, lookup_table=thru,
meta=meta)
|
[
"def",
"etau_madau",
"(",
"wave",
",",
"z",
",",
"*",
"*",
"kwargs",
")",
":",
"if",
"not",
"isinstance",
"(",
"z",
",",
"numbers",
".",
"Real",
")",
":",
"raise",
"exceptions",
".",
"SynphotError",
"(",
"'Redshift must be a real scalar number.'",
")",
"if",
"np",
".",
"isscalar",
"(",
"wave",
")",
"or",
"len",
"(",
"wave",
")",
"<=",
"1",
":",
"raise",
"exceptions",
".",
"SynphotError",
"(",
"'Wavelength has too few data points'",
")",
"wave",
"=",
"units",
".",
"validate_quantity",
"(",
"wave",
",",
"u",
".",
"AA",
",",
"*",
"*",
"kwargs",
")",
".",
"value",
"ll",
"=",
"912.0",
"c",
"=",
"np",
".",
"array",
"(",
"[",
"3.6e-3",
",",
"1.7e-3",
",",
"1.2e-3",
",",
"9.3e-4",
"]",
")",
"el",
"=",
"np",
".",
"array",
"(",
"[",
"1216",
",",
"1026",
",",
"973",
",",
"950",
"]",
",",
"dtype",
"=",
"np",
".",
"float",
")",
"# noqa",
"tau",
"=",
"np",
".",
"zeros_like",
"(",
"wave",
",",
"dtype",
"=",
"np",
".",
"float",
")",
"xe",
"=",
"1.0",
"+",
"z",
"# Lyman series",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"el",
")",
")",
":",
"tau",
"=",
"np",
".",
"where",
"(",
"wave",
"<=",
"el",
"[",
"i",
"]",
"*",
"xe",
",",
"tau",
"+",
"c",
"[",
"i",
"]",
"*",
"(",
"wave",
"/",
"el",
"[",
"i",
"]",
")",
"**",
"3.46",
",",
"tau",
")",
"# Photoelectric absorption",
"xc",
"=",
"wave",
"/",
"ll",
"xc3",
"=",
"xc",
"**",
"3",
"tau",
"=",
"np",
".",
"where",
"(",
"wave",
"<=",
"ll",
"*",
"xe",
",",
"(",
"tau",
"+",
"0.25",
"*",
"xc3",
"*",
"(",
"xe",
"**",
"0.46",
"-",
"xc",
"**",
"0.46",
")",
"+",
"9.4",
"*",
"xc",
"**",
"1.5",
"*",
"(",
"xe",
"**",
"0.18",
"-",
"xc",
"**",
"0.18",
")",
"-",
"0.7",
"*",
"xc3",
"*",
"(",
"xc",
"**",
"(",
"-",
"1.32",
")",
"-",
"xe",
"**",
"(",
"-",
"1.32",
")",
")",
"-",
"0.023",
"*",
"(",
"xe",
"**",
"1.68",
"-",
"xc",
"**",
"1.68",
")",
")",
",",
"tau",
")",
"thru",
"=",
"np",
".",
"where",
"(",
"tau",
">",
"700.",
",",
"0.",
",",
"np",
".",
"exp",
"(",
"-",
"tau",
")",
")",
"meta",
"=",
"{",
"'descrip'",
":",
"'Madau 1995 extinction for z={0}'",
".",
"format",
"(",
"z",
")",
"}",
"return",
"ExtinctionCurve",
"(",
"ExtinctionModel1D",
",",
"points",
"=",
"wave",
",",
"lookup_table",
"=",
"thru",
",",
"meta",
"=",
"meta",
")"
] |
Madau 1995 extinction for a galaxy at given redshift.
This is the Lyman-alpha prescription from the photo-z code BPZ.
The Lyman-alpha forest approximately has an effective
"throughput" which is a function of redshift and
rest-frame wavelength.
One would multiply the SEDs by this factor before
passing it through an instrument filter.
This approximation is from Footnote 3 of
:ref:`Madau et al. (1995) <synphot-ref-madau1995>`.
This is claimed accurate to 5%.
The scatter in this factor (due to different lines of sight)
is huge, as shown in Madau's Fig. 3 (top panel);
The figure's bottom panel shows a redshifted version of the
"exact" prescription.
Parameters
----------
wave : array-like or `~astropy.units.quantity.Quantity`
Redshifted wavelength values.
Non-redshifted wavelength is ``wave / (1 + z)``.
z : number
Redshift.
kwargs : dict
Equivalencies for unit conversion, see
:func:`~synphot.units.validate_quantity`.
Returns
-------
extcurve : `ExtinctionCurve`
Extinction curve to apply to the redshifted spectrum.
|
[
"Madau",
"1995",
"extinction",
"for",
"a",
"galaxy",
"at",
"given",
"redshift",
".",
"This",
"is",
"the",
"Lyman",
"-",
"alpha",
"prescription",
"from",
"the",
"photo",
"-",
"z",
"code",
"BPZ",
"."
] |
train
|
https://github.com/spacetelescope/synphot_refactor/blob/9c064f3cff0c41dd8acadc0f67c6350931275b9f/synphot/reddening.py#L244-L315
|
spacetelescope/synphot_refactor
|
synphot/reddening.py
|
ReddeningLaw.extinction_curve
|
def extinction_curve(self, ebv, wavelengths=None):
"""Generate extinction curve.
.. math::
A(V) = R(V) \\; \\times \\; E(B-V)
THRU = 10^{-0.4 \\; A(V)}
Parameters
----------
ebv : float or `~astropy.units.quantity.Quantity`
:math:`E(B-V)` value in magnitude.
wavelengths : array-like, `~astropy.units.quantity.Quantity`, or `None`
Wavelength values for sampling.
If not a Quantity, assumed to be in Angstrom.
If `None`, ``self.waveset`` is used.
Returns
-------
extcurve : `ExtinctionCurve`
Empirical extinction curve.
Raises
------
synphot.exceptions.SynphotError
Invalid input.
"""
if isinstance(ebv, u.Quantity) and ebv.unit.decompose() == u.mag:
ebv = ebv.value
elif not isinstance(ebv, numbers.Real):
raise exceptions.SynphotError('E(B-V)={0} is invalid.'.format(ebv))
x = self._validate_wavelengths(wavelengths).value
y = 10 ** (-0.4 * self(x).value * ebv)
header = {
'E(B-V)': ebv,
'ReddeningLaw': self.meta.get('expr', 'unknown')}
return ExtinctionCurve(ExtinctionModel1D, points=x, lookup_table=y,
meta={'header': header})
|
python
|
def extinction_curve(self, ebv, wavelengths=None):
"""Generate extinction curve.
.. math::
A(V) = R(V) \\; \\times \\; E(B-V)
THRU = 10^{-0.4 \\; A(V)}
Parameters
----------
ebv : float or `~astropy.units.quantity.Quantity`
:math:`E(B-V)` value in magnitude.
wavelengths : array-like, `~astropy.units.quantity.Quantity`, or `None`
Wavelength values for sampling.
If not a Quantity, assumed to be in Angstrom.
If `None`, ``self.waveset`` is used.
Returns
-------
extcurve : `ExtinctionCurve`
Empirical extinction curve.
Raises
------
synphot.exceptions.SynphotError
Invalid input.
"""
if isinstance(ebv, u.Quantity) and ebv.unit.decompose() == u.mag:
ebv = ebv.value
elif not isinstance(ebv, numbers.Real):
raise exceptions.SynphotError('E(B-V)={0} is invalid.'.format(ebv))
x = self._validate_wavelengths(wavelengths).value
y = 10 ** (-0.4 * self(x).value * ebv)
header = {
'E(B-V)': ebv,
'ReddeningLaw': self.meta.get('expr', 'unknown')}
return ExtinctionCurve(ExtinctionModel1D, points=x, lookup_table=y,
meta={'header': header})
|
[
"def",
"extinction_curve",
"(",
"self",
",",
"ebv",
",",
"wavelengths",
"=",
"None",
")",
":",
"if",
"isinstance",
"(",
"ebv",
",",
"u",
".",
"Quantity",
")",
"and",
"ebv",
".",
"unit",
".",
"decompose",
"(",
")",
"==",
"u",
".",
"mag",
":",
"ebv",
"=",
"ebv",
".",
"value",
"elif",
"not",
"isinstance",
"(",
"ebv",
",",
"numbers",
".",
"Real",
")",
":",
"raise",
"exceptions",
".",
"SynphotError",
"(",
"'E(B-V)={0} is invalid.'",
".",
"format",
"(",
"ebv",
")",
")",
"x",
"=",
"self",
".",
"_validate_wavelengths",
"(",
"wavelengths",
")",
".",
"value",
"y",
"=",
"10",
"**",
"(",
"-",
"0.4",
"*",
"self",
"(",
"x",
")",
".",
"value",
"*",
"ebv",
")",
"header",
"=",
"{",
"'E(B-V)'",
":",
"ebv",
",",
"'ReddeningLaw'",
":",
"self",
".",
"meta",
".",
"get",
"(",
"'expr'",
",",
"'unknown'",
")",
"}",
"return",
"ExtinctionCurve",
"(",
"ExtinctionModel1D",
",",
"points",
"=",
"x",
",",
"lookup_table",
"=",
"y",
",",
"meta",
"=",
"{",
"'header'",
":",
"header",
"}",
")"
] |
Generate extinction curve.
.. math::
A(V) = R(V) \\; \\times \\; E(B-V)
THRU = 10^{-0.4 \\; A(V)}
Parameters
----------
ebv : float or `~astropy.units.quantity.Quantity`
:math:`E(B-V)` value in magnitude.
wavelengths : array-like, `~astropy.units.quantity.Quantity`, or `None`
Wavelength values for sampling.
If not a Quantity, assumed to be in Angstrom.
If `None`, ``self.waveset`` is used.
Returns
-------
extcurve : `ExtinctionCurve`
Empirical extinction curve.
Raises
------
synphot.exceptions.SynphotError
Invalid input.
|
[
"Generate",
"extinction",
"curve",
"."
] |
train
|
https://github.com/spacetelescope/synphot_refactor/blob/9c064f3cff0c41dd8acadc0f67c6350931275b9f/synphot/reddening.py#L42-L84
|
spacetelescope/synphot_refactor
|
synphot/reddening.py
|
ReddeningLaw.to_fits
|
def to_fits(self, filename, wavelengths=None, **kwargs):
"""Write the reddening law to a FITS file.
:math:`R(V)` column is automatically named 'Av/E(B-V)'.
Parameters
----------
filename : str
Output filename.
wavelengths : array-like, `~astropy.units.quantity.Quantity`, or `None`
Wavelength values for sampling.
If not a Quantity, assumed to be in Angstrom.
If `None`, ``self.waveset`` is used.
kwargs : dict
Keywords accepted by :func:`~synphot.specio.write_fits_spec`.
"""
w, y = self._get_arrays(wavelengths)
kwargs['flux_col'] = 'Av/E(B-V)'
kwargs['flux_unit'] = self._internal_flux_unit
# No need to trim/pad zeroes, unless user chooses to do so.
if 'pad_zero_ends' not in kwargs:
kwargs['pad_zero_ends'] = False
if 'trim_zero' not in kwargs:
kwargs['trim_zero'] = False
# There are some standard keywords that should be added
# to the extension header.
bkeys = {'tdisp1': 'G15.7', 'tdisp2': 'G15.7'}
if 'expr' in self.meta:
bkeys['expr'] = (self.meta['expr'], 'synphot expression')
if 'ext_header' in kwargs:
kwargs['ext_header'].update(bkeys)
else:
kwargs['ext_header'] = bkeys
specio.write_fits_spec(filename, w, y, **kwargs)
|
python
|
def to_fits(self, filename, wavelengths=None, **kwargs):
"""Write the reddening law to a FITS file.
:math:`R(V)` column is automatically named 'Av/E(B-V)'.
Parameters
----------
filename : str
Output filename.
wavelengths : array-like, `~astropy.units.quantity.Quantity`, or `None`
Wavelength values for sampling.
If not a Quantity, assumed to be in Angstrom.
If `None`, ``self.waveset`` is used.
kwargs : dict
Keywords accepted by :func:`~synphot.specio.write_fits_spec`.
"""
w, y = self._get_arrays(wavelengths)
kwargs['flux_col'] = 'Av/E(B-V)'
kwargs['flux_unit'] = self._internal_flux_unit
# No need to trim/pad zeroes, unless user chooses to do so.
if 'pad_zero_ends' not in kwargs:
kwargs['pad_zero_ends'] = False
if 'trim_zero' not in kwargs:
kwargs['trim_zero'] = False
# There are some standard keywords that should be added
# to the extension header.
bkeys = {'tdisp1': 'G15.7', 'tdisp2': 'G15.7'}
if 'expr' in self.meta:
bkeys['expr'] = (self.meta['expr'], 'synphot expression')
if 'ext_header' in kwargs:
kwargs['ext_header'].update(bkeys)
else:
kwargs['ext_header'] = bkeys
specio.write_fits_spec(filename, w, y, **kwargs)
|
[
"def",
"to_fits",
"(",
"self",
",",
"filename",
",",
"wavelengths",
"=",
"None",
",",
"*",
"*",
"kwargs",
")",
":",
"w",
",",
"y",
"=",
"self",
".",
"_get_arrays",
"(",
"wavelengths",
")",
"kwargs",
"[",
"'flux_col'",
"]",
"=",
"'Av/E(B-V)'",
"kwargs",
"[",
"'flux_unit'",
"]",
"=",
"self",
".",
"_internal_flux_unit",
"# No need to trim/pad zeroes, unless user chooses to do so.",
"if",
"'pad_zero_ends'",
"not",
"in",
"kwargs",
":",
"kwargs",
"[",
"'pad_zero_ends'",
"]",
"=",
"False",
"if",
"'trim_zero'",
"not",
"in",
"kwargs",
":",
"kwargs",
"[",
"'trim_zero'",
"]",
"=",
"False",
"# There are some standard keywords that should be added",
"# to the extension header.",
"bkeys",
"=",
"{",
"'tdisp1'",
":",
"'G15.7'",
",",
"'tdisp2'",
":",
"'G15.7'",
"}",
"if",
"'expr'",
"in",
"self",
".",
"meta",
":",
"bkeys",
"[",
"'expr'",
"]",
"=",
"(",
"self",
".",
"meta",
"[",
"'expr'",
"]",
",",
"'synphot expression'",
")",
"if",
"'ext_header'",
"in",
"kwargs",
":",
"kwargs",
"[",
"'ext_header'",
"]",
".",
"update",
"(",
"bkeys",
")",
"else",
":",
"kwargs",
"[",
"'ext_header'",
"]",
"=",
"bkeys",
"specio",
".",
"write_fits_spec",
"(",
"filename",
",",
"w",
",",
"y",
",",
"*",
"*",
"kwargs",
")"
] |
Write the reddening law to a FITS file.
:math:`R(V)` column is automatically named 'Av/E(B-V)'.
Parameters
----------
filename : str
Output filename.
wavelengths : array-like, `~astropy.units.quantity.Quantity`, or `None`
Wavelength values for sampling.
If not a Quantity, assumed to be in Angstrom.
If `None`, ``self.waveset`` is used.
kwargs : dict
Keywords accepted by :func:`~synphot.specio.write_fits_spec`.
|
[
"Write",
"the",
"reddening",
"law",
"to",
"a",
"FITS",
"file",
"."
] |
train
|
https://github.com/spacetelescope/synphot_refactor/blob/9c064f3cff0c41dd8acadc0f67c6350931275b9f/synphot/reddening.py#L86-L128
|
spacetelescope/synphot_refactor
|
synphot/reddening.py
|
ReddeningLaw.from_file
|
def from_file(cls, filename, **kwargs):
"""Create a reddening law from file.
If filename has 'fits' or 'fit' suffix, it is read as FITS.
Otherwise, it is read as ASCII.
Parameters
----------
filename : str
Reddening law filename.
kwargs : dict
Keywords acceptable by
:func:`~synphot.specio.read_fits_spec` (if FITS) or
:func:`~synphot.specio.read_ascii_spec` (if ASCII).
Returns
-------
redlaw : `ReddeningLaw`
Empirical reddening law.
"""
if 'flux_unit' not in kwargs:
kwargs['flux_unit'] = cls._internal_flux_unit
if ((filename.endswith('fits') or filename.endswith('fit')) and
'flux_col' not in kwargs):
kwargs['flux_col'] = 'Av/E(B-V)'
header, wavelengths, rvs = specio.read_spec(filename, **kwargs)
return cls(Empirical1D, points=wavelengths, lookup_table=rvs,
meta={'header': header})
|
python
|
def from_file(cls, filename, **kwargs):
"""Create a reddening law from file.
If filename has 'fits' or 'fit' suffix, it is read as FITS.
Otherwise, it is read as ASCII.
Parameters
----------
filename : str
Reddening law filename.
kwargs : dict
Keywords acceptable by
:func:`~synphot.specio.read_fits_spec` (if FITS) or
:func:`~synphot.specio.read_ascii_spec` (if ASCII).
Returns
-------
redlaw : `ReddeningLaw`
Empirical reddening law.
"""
if 'flux_unit' not in kwargs:
kwargs['flux_unit'] = cls._internal_flux_unit
if ((filename.endswith('fits') or filename.endswith('fit')) and
'flux_col' not in kwargs):
kwargs['flux_col'] = 'Av/E(B-V)'
header, wavelengths, rvs = specio.read_spec(filename, **kwargs)
return cls(Empirical1D, points=wavelengths, lookup_table=rvs,
meta={'header': header})
|
[
"def",
"from_file",
"(",
"cls",
",",
"filename",
",",
"*",
"*",
"kwargs",
")",
":",
"if",
"'flux_unit'",
"not",
"in",
"kwargs",
":",
"kwargs",
"[",
"'flux_unit'",
"]",
"=",
"cls",
".",
"_internal_flux_unit",
"if",
"(",
"(",
"filename",
".",
"endswith",
"(",
"'fits'",
")",
"or",
"filename",
".",
"endswith",
"(",
"'fit'",
")",
")",
"and",
"'flux_col'",
"not",
"in",
"kwargs",
")",
":",
"kwargs",
"[",
"'flux_col'",
"]",
"=",
"'Av/E(B-V)'",
"header",
",",
"wavelengths",
",",
"rvs",
"=",
"specio",
".",
"read_spec",
"(",
"filename",
",",
"*",
"*",
"kwargs",
")",
"return",
"cls",
"(",
"Empirical1D",
",",
"points",
"=",
"wavelengths",
",",
"lookup_table",
"=",
"rvs",
",",
"meta",
"=",
"{",
"'header'",
":",
"header",
"}",
")"
] |
Create a reddening law from file.
If filename has 'fits' or 'fit' suffix, it is read as FITS.
Otherwise, it is read as ASCII.
Parameters
----------
filename : str
Reddening law filename.
kwargs : dict
Keywords acceptable by
:func:`~synphot.specio.read_fits_spec` (if FITS) or
:func:`~synphot.specio.read_ascii_spec` (if ASCII).
Returns
-------
redlaw : `ReddeningLaw`
Empirical reddening law.
|
[
"Create",
"a",
"reddening",
"law",
"from",
"file",
"."
] |
train
|
https://github.com/spacetelescope/synphot_refactor/blob/9c064f3cff0c41dd8acadc0f67c6350931275b9f/synphot/reddening.py#L131-L163
|
spacetelescope/synphot_refactor
|
synphot/reddening.py
|
ReddeningLaw.from_extinction_model
|
def from_extinction_model(cls, modelname, **kwargs):
"""Load :ref:`pre-defined extinction model <synphot_reddening>`.
Parameters
----------
modelname : str
Extinction model name. Choose from 'lmc30dor', 'lmcavg', 'mwavg',
'mwdense', 'mwrv21', 'mwrv40', 'smcbar', or 'xgalsb'.
kwargs : dict
Keywords acceptable by :func:`~synphot.specio.read_remote_spec`.
Returns
-------
redlaw : `ReddeningLaw`
Empirical reddening law.
Raises
------
synphot.exceptions.SynphotError
Invalid extinction model name.
"""
modelname = modelname.lower()
# Select filename based on model name
if modelname == 'lmc30dor':
cfgitem = Conf.lmc30dor_file
elif modelname == 'lmcavg':
cfgitem = Conf.lmcavg_file
elif modelname == 'mwavg':
cfgitem = Conf.mwavg_file
elif modelname == 'mwdense':
cfgitem = Conf.mwdense_file
elif modelname == 'mwrv21':
cfgitem = Conf.mwrv21_file
elif modelname == 'mwrv40':
cfgitem = Conf.mwrv40_file
elif modelname == 'smcbar':
cfgitem = Conf.smcbar_file
elif modelname == 'xgalsb':
cfgitem = Conf.xgal_file
else:
raise exceptions.SynphotError(
'Extinction model {0} is invalid.'.format(modelname))
filename = cfgitem()
if 'flux_unit' not in kwargs:
kwargs['flux_unit'] = cls._internal_flux_unit
if ((filename.endswith('fits') or filename.endswith('fit')) and
'flux_col' not in kwargs):
kwargs['flux_col'] = 'Av/E(B-V)'
header, wavelengths, rvs = specio.read_remote_spec(filename, **kwargs)
header['filename'] = filename
header['descrip'] = cfgitem.description
meta = {'header': header, 'expr': modelname}
return cls(Empirical1D, points=wavelengths, lookup_table=rvs,
meta=meta)
|
python
|
def from_extinction_model(cls, modelname, **kwargs):
"""Load :ref:`pre-defined extinction model <synphot_reddening>`.
Parameters
----------
modelname : str
Extinction model name. Choose from 'lmc30dor', 'lmcavg', 'mwavg',
'mwdense', 'mwrv21', 'mwrv40', 'smcbar', or 'xgalsb'.
kwargs : dict
Keywords acceptable by :func:`~synphot.specio.read_remote_spec`.
Returns
-------
redlaw : `ReddeningLaw`
Empirical reddening law.
Raises
------
synphot.exceptions.SynphotError
Invalid extinction model name.
"""
modelname = modelname.lower()
# Select filename based on model name
if modelname == 'lmc30dor':
cfgitem = Conf.lmc30dor_file
elif modelname == 'lmcavg':
cfgitem = Conf.lmcavg_file
elif modelname == 'mwavg':
cfgitem = Conf.mwavg_file
elif modelname == 'mwdense':
cfgitem = Conf.mwdense_file
elif modelname == 'mwrv21':
cfgitem = Conf.mwrv21_file
elif modelname == 'mwrv40':
cfgitem = Conf.mwrv40_file
elif modelname == 'smcbar':
cfgitem = Conf.smcbar_file
elif modelname == 'xgalsb':
cfgitem = Conf.xgal_file
else:
raise exceptions.SynphotError(
'Extinction model {0} is invalid.'.format(modelname))
filename = cfgitem()
if 'flux_unit' not in kwargs:
kwargs['flux_unit'] = cls._internal_flux_unit
if ((filename.endswith('fits') or filename.endswith('fit')) and
'flux_col' not in kwargs):
kwargs['flux_col'] = 'Av/E(B-V)'
header, wavelengths, rvs = specio.read_remote_spec(filename, **kwargs)
header['filename'] = filename
header['descrip'] = cfgitem.description
meta = {'header': header, 'expr': modelname}
return cls(Empirical1D, points=wavelengths, lookup_table=rvs,
meta=meta)
|
[
"def",
"from_extinction_model",
"(",
"cls",
",",
"modelname",
",",
"*",
"*",
"kwargs",
")",
":",
"modelname",
"=",
"modelname",
".",
"lower",
"(",
")",
"# Select filename based on model name",
"if",
"modelname",
"==",
"'lmc30dor'",
":",
"cfgitem",
"=",
"Conf",
".",
"lmc30dor_file",
"elif",
"modelname",
"==",
"'lmcavg'",
":",
"cfgitem",
"=",
"Conf",
".",
"lmcavg_file",
"elif",
"modelname",
"==",
"'mwavg'",
":",
"cfgitem",
"=",
"Conf",
".",
"mwavg_file",
"elif",
"modelname",
"==",
"'mwdense'",
":",
"cfgitem",
"=",
"Conf",
".",
"mwdense_file",
"elif",
"modelname",
"==",
"'mwrv21'",
":",
"cfgitem",
"=",
"Conf",
".",
"mwrv21_file",
"elif",
"modelname",
"==",
"'mwrv40'",
":",
"cfgitem",
"=",
"Conf",
".",
"mwrv40_file",
"elif",
"modelname",
"==",
"'smcbar'",
":",
"cfgitem",
"=",
"Conf",
".",
"smcbar_file",
"elif",
"modelname",
"==",
"'xgalsb'",
":",
"cfgitem",
"=",
"Conf",
".",
"xgal_file",
"else",
":",
"raise",
"exceptions",
".",
"SynphotError",
"(",
"'Extinction model {0} is invalid.'",
".",
"format",
"(",
"modelname",
")",
")",
"filename",
"=",
"cfgitem",
"(",
")",
"if",
"'flux_unit'",
"not",
"in",
"kwargs",
":",
"kwargs",
"[",
"'flux_unit'",
"]",
"=",
"cls",
".",
"_internal_flux_unit",
"if",
"(",
"(",
"filename",
".",
"endswith",
"(",
"'fits'",
")",
"or",
"filename",
".",
"endswith",
"(",
"'fit'",
")",
")",
"and",
"'flux_col'",
"not",
"in",
"kwargs",
")",
":",
"kwargs",
"[",
"'flux_col'",
"]",
"=",
"'Av/E(B-V)'",
"header",
",",
"wavelengths",
",",
"rvs",
"=",
"specio",
".",
"read_remote_spec",
"(",
"filename",
",",
"*",
"*",
"kwargs",
")",
"header",
"[",
"'filename'",
"]",
"=",
"filename",
"header",
"[",
"'descrip'",
"]",
"=",
"cfgitem",
".",
"description",
"meta",
"=",
"{",
"'header'",
":",
"header",
",",
"'expr'",
":",
"modelname",
"}",
"return",
"cls",
"(",
"Empirical1D",
",",
"points",
"=",
"wavelengths",
",",
"lookup_table",
"=",
"rvs",
",",
"meta",
"=",
"meta",
")"
] |
Load :ref:`pre-defined extinction model <synphot_reddening>`.
Parameters
----------
modelname : str
Extinction model name. Choose from 'lmc30dor', 'lmcavg', 'mwavg',
'mwdense', 'mwrv21', 'mwrv40', 'smcbar', or 'xgalsb'.
kwargs : dict
Keywords acceptable by :func:`~synphot.specio.read_remote_spec`.
Returns
-------
redlaw : `ReddeningLaw`
Empirical reddening law.
Raises
------
synphot.exceptions.SynphotError
Invalid extinction model name.
|
[
"Load",
":",
"ref",
":",
"pre",
"-",
"defined",
"extinction",
"model",
"<synphot_reddening",
">",
"."
] |
train
|
https://github.com/spacetelescope/synphot_refactor/blob/9c064f3cff0c41dd8acadc0f67c6350931275b9f/synphot/reddening.py#L166-L227
|
Julius2342/pyvlx
|
pyvlx/get_version.py
|
GetVersion.handle_frame
|
async def handle_frame(self, frame):
"""Handle incoming API frame, return True if this was the expected frame."""
if not isinstance(frame, FrameGetVersionConfirmation):
return False
self.version = frame.version
self.success = True
return True
|
python
|
async def handle_frame(self, frame):
"""Handle incoming API frame, return True if this was the expected frame."""
if not isinstance(frame, FrameGetVersionConfirmation):
return False
self.version = frame.version
self.success = True
return True
|
[
"async",
"def",
"handle_frame",
"(",
"self",
",",
"frame",
")",
":",
"if",
"not",
"isinstance",
"(",
"frame",
",",
"FrameGetVersionConfirmation",
")",
":",
"return",
"False",
"self",
".",
"version",
"=",
"frame",
".",
"version",
"self",
".",
"success",
"=",
"True",
"return",
"True"
] |
Handle incoming API frame, return True if this was the expected frame.
|
[
"Handle",
"incoming",
"API",
"frame",
"return",
"True",
"if",
"this",
"was",
"the",
"expected",
"frame",
"."
] |
train
|
https://github.com/Julius2342/pyvlx/blob/ee78e1324bcb1be5b8d1a9d05ab5496b72eae848/pyvlx/get_version.py#L15-L21
|
Julius2342/pyvlx
|
pyvlx/frames/frame.py
|
FrameBase.validate_payload_len
|
def validate_payload_len(self, payload):
"""Validate payload len."""
if not hasattr(self, "PAYLOAD_LEN"):
# No fixed payload len, e.g. within FrameGetSceneListNotification
return
# pylint: disable=no-member
if len(payload) != self.PAYLOAD_LEN:
raise PyVLXException("Invalid payload len", expected_len=self.PAYLOAD_LEN, current_len=len(payload), frame_type=type(self).__name__)
|
python
|
def validate_payload_len(self, payload):
"""Validate payload len."""
if not hasattr(self, "PAYLOAD_LEN"):
# No fixed payload len, e.g. within FrameGetSceneListNotification
return
# pylint: disable=no-member
if len(payload) != self.PAYLOAD_LEN:
raise PyVLXException("Invalid payload len", expected_len=self.PAYLOAD_LEN, current_len=len(payload), frame_type=type(self).__name__)
|
[
"def",
"validate_payload_len",
"(",
"self",
",",
"payload",
")",
":",
"if",
"not",
"hasattr",
"(",
"self",
",",
"\"PAYLOAD_LEN\"",
")",
":",
"# No fixed payload len, e.g. within FrameGetSceneListNotification",
"return",
"# pylint: disable=no-member",
"if",
"len",
"(",
"payload",
")",
"!=",
"self",
".",
"PAYLOAD_LEN",
":",
"raise",
"PyVLXException",
"(",
"\"Invalid payload len\"",
",",
"expected_len",
"=",
"self",
".",
"PAYLOAD_LEN",
",",
"current_len",
"=",
"len",
"(",
"payload",
")",
",",
"frame_type",
"=",
"type",
"(",
"self",
")",
".",
"__name__",
")"
] |
Validate payload len.
|
[
"Validate",
"payload",
"len",
"."
] |
train
|
https://github.com/Julius2342/pyvlx/blob/ee78e1324bcb1be5b8d1a9d05ab5496b72eae848/pyvlx/frames/frame.py#L22-L29
|
Julius2342/pyvlx
|
pyvlx/frames/frame.py
|
FrameBase.build_frame
|
def build_frame(command, payload):
"""Build raw bytes from command and payload."""
packet_length = 2 + len(payload) + 1
ret = struct.pack("BB", 0, packet_length)
ret += struct.pack(">H", command.value)
ret += payload
ret += struct.pack("B", calc_crc(ret))
return ret
|
python
|
def build_frame(command, payload):
"""Build raw bytes from command and payload."""
packet_length = 2 + len(payload) + 1
ret = struct.pack("BB", 0, packet_length)
ret += struct.pack(">H", command.value)
ret += payload
ret += struct.pack("B", calc_crc(ret))
return ret
|
[
"def",
"build_frame",
"(",
"command",
",",
"payload",
")",
":",
"packet_length",
"=",
"2",
"+",
"len",
"(",
"payload",
")",
"+",
"1",
"ret",
"=",
"struct",
".",
"pack",
"(",
"\"BB\"",
",",
"0",
",",
"packet_length",
")",
"ret",
"+=",
"struct",
".",
"pack",
"(",
"\">H\"",
",",
"command",
".",
"value",
")",
"ret",
"+=",
"payload",
"ret",
"+=",
"struct",
".",
"pack",
"(",
"\"B\"",
",",
"calc_crc",
"(",
"ret",
")",
")",
"return",
"ret"
] |
Build raw bytes from command and payload.
|
[
"Build",
"raw",
"bytes",
"from",
"command",
"and",
"payload",
"."
] |
train
|
https://github.com/Julius2342/pyvlx/blob/ee78e1324bcb1be5b8d1a9d05ab5496b72eae848/pyvlx/frames/frame.py#L45-L52
|
Julius2342/pyvlx
|
pyvlx/scene.py
|
Scene.run
|
async def run(self, wait_for_completion=True):
"""Run scene.
Parameters:
* wait_for_completion: If set, function will return
after device has reached target position.
"""
activate_scene = ActivateScene(
pyvlx=self.pyvlx,
wait_for_completion=wait_for_completion,
scene_id=self.scene_id)
await activate_scene.do_api_call()
if not activate_scene.success:
raise PyVLXException("Unable to activate scene")
|
python
|
async def run(self, wait_for_completion=True):
"""Run scene.
Parameters:
* wait_for_completion: If set, function will return
after device has reached target position.
"""
activate_scene = ActivateScene(
pyvlx=self.pyvlx,
wait_for_completion=wait_for_completion,
scene_id=self.scene_id)
await activate_scene.do_api_call()
if not activate_scene.success:
raise PyVLXException("Unable to activate scene")
|
[
"async",
"def",
"run",
"(",
"self",
",",
"wait_for_completion",
"=",
"True",
")",
":",
"activate_scene",
"=",
"ActivateScene",
"(",
"pyvlx",
"=",
"self",
".",
"pyvlx",
",",
"wait_for_completion",
"=",
"wait_for_completion",
",",
"scene_id",
"=",
"self",
".",
"scene_id",
")",
"await",
"activate_scene",
".",
"do_api_call",
"(",
")",
"if",
"not",
"activate_scene",
".",
"success",
":",
"raise",
"PyVLXException",
"(",
"\"Unable to activate scene\"",
")"
] |
Run scene.
Parameters:
* wait_for_completion: If set, function will return
after device has reached target position.
|
[
"Run",
"scene",
"."
] |
train
|
https://github.com/Julius2342/pyvlx/blob/ee78e1324bcb1be5b8d1a9d05ab5496b72eae848/pyvlx/scene.py#L23-L37
|
Julius2342/pyvlx
|
old_api/pyvlx/scenes.py
|
Scenes.add
|
def add(self, scene):
"""Add scene."""
if not isinstance(scene, Scene):
raise TypeError()
self.__scenes.append(scene)
|
python
|
def add(self, scene):
"""Add scene."""
if not isinstance(scene, Scene):
raise TypeError()
self.__scenes.append(scene)
|
[
"def",
"add",
"(",
"self",
",",
"scene",
")",
":",
"if",
"not",
"isinstance",
"(",
"scene",
",",
"Scene",
")",
":",
"raise",
"TypeError",
"(",
")",
"self",
".",
"__scenes",
".",
"append",
"(",
"scene",
")"
] |
Add scene.
|
[
"Add",
"scene",
"."
] |
train
|
https://github.com/Julius2342/pyvlx/blob/ee78e1324bcb1be5b8d1a9d05ab5496b72eae848/old_api/pyvlx/scenes.py#L33-L37
|
Julius2342/pyvlx
|
old_api/pyvlx/scenes.py
|
Scenes.load
|
async def load(self):
"""Load scenes from KLF 200."""
json_response = await self.pyvlx.interface.api_call('scenes', 'get')
self.data_import(json_response)
|
python
|
async def load(self):
"""Load scenes from KLF 200."""
json_response = await self.pyvlx.interface.api_call('scenes', 'get')
self.data_import(json_response)
|
[
"async",
"def",
"load",
"(",
"self",
")",
":",
"json_response",
"=",
"await",
"self",
".",
"pyvlx",
".",
"interface",
".",
"api_call",
"(",
"'scenes'",
",",
"'get'",
")",
"self",
".",
"data_import",
"(",
"json_response",
")"
] |
Load scenes from KLF 200.
|
[
"Load",
"scenes",
"from",
"KLF",
"200",
"."
] |
train
|
https://github.com/Julius2342/pyvlx/blob/ee78e1324bcb1be5b8d1a9d05ab5496b72eae848/old_api/pyvlx/scenes.py#L39-L42
|
Julius2342/pyvlx
|
old_api/pyvlx/scenes.py
|
Scenes.data_import
|
def data_import(self, json_response):
"""Import scenes from JSON response."""
if 'data' not in json_response:
raise PyVLXException('no element data found: {0}'.format(
json.dumps(json_response)))
data = json_response['data']
for item in data:
self.load_scene(item)
|
python
|
def data_import(self, json_response):
"""Import scenes from JSON response."""
if 'data' not in json_response:
raise PyVLXException('no element data found: {0}'.format(
json.dumps(json_response)))
data = json_response['data']
for item in data:
self.load_scene(item)
|
[
"def",
"data_import",
"(",
"self",
",",
"json_response",
")",
":",
"if",
"'data'",
"not",
"in",
"json_response",
":",
"raise",
"PyVLXException",
"(",
"'no element data found: {0}'",
".",
"format",
"(",
"json",
".",
"dumps",
"(",
"json_response",
")",
")",
")",
"data",
"=",
"json_response",
"[",
"'data'",
"]",
"for",
"item",
"in",
"data",
":",
"self",
".",
"load_scene",
"(",
"item",
")"
] |
Import scenes from JSON response.
|
[
"Import",
"scenes",
"from",
"JSON",
"response",
"."
] |
train
|
https://github.com/Julius2342/pyvlx/blob/ee78e1324bcb1be5b8d1a9d05ab5496b72eae848/old_api/pyvlx/scenes.py#L44-L51
|
Julius2342/pyvlx
|
old_api/pyvlx/scenes.py
|
Scenes.load_scene
|
def load_scene(self, item):
"""Load scene from json."""
scene = Scene.from_config(self.pyvlx, item)
self.add(scene)
|
python
|
def load_scene(self, item):
"""Load scene from json."""
scene = Scene.from_config(self.pyvlx, item)
self.add(scene)
|
[
"def",
"load_scene",
"(",
"self",
",",
"item",
")",
":",
"scene",
"=",
"Scene",
".",
"from_config",
"(",
"self",
".",
"pyvlx",
",",
"item",
")",
"self",
".",
"add",
"(",
"scene",
")"
] |
Load scene from json.
|
[
"Load",
"scene",
"from",
"json",
"."
] |
train
|
https://github.com/Julius2342/pyvlx/blob/ee78e1324bcb1be5b8d1a9d05ab5496b72eae848/old_api/pyvlx/scenes.py#L53-L56
|
Julius2342/pyvlx
|
pyvlx/get_state.py
|
GetState.handle_frame
|
async def handle_frame(self, frame):
"""Handle incoming API frame, return True if this was the expected frame."""
if not isinstance(frame, FrameGetStateConfirmation):
return False
self.success = True
self.gateway_state = frame.gateway_state
self.gateway_sub_state = frame.gateway_sub_state
return True
|
python
|
async def handle_frame(self, frame):
"""Handle incoming API frame, return True if this was the expected frame."""
if not isinstance(frame, FrameGetStateConfirmation):
return False
self.success = True
self.gateway_state = frame.gateway_state
self.gateway_sub_state = frame.gateway_sub_state
return True
|
[
"async",
"def",
"handle_frame",
"(",
"self",
",",
"frame",
")",
":",
"if",
"not",
"isinstance",
"(",
"frame",
",",
"FrameGetStateConfirmation",
")",
":",
"return",
"False",
"self",
".",
"success",
"=",
"True",
"self",
".",
"gateway_state",
"=",
"frame",
".",
"gateway_state",
"self",
".",
"gateway_sub_state",
"=",
"frame",
".",
"gateway_sub_state",
"return",
"True"
] |
Handle incoming API frame, return True if this was the expected frame.
|
[
"Handle",
"incoming",
"API",
"frame",
"return",
"True",
"if",
"this",
"was",
"the",
"expected",
"frame",
"."
] |
train
|
https://github.com/Julius2342/pyvlx/blob/ee78e1324bcb1be5b8d1a9d05ab5496b72eae848/pyvlx/get_state.py#L16-L23
|
Julius2342/pyvlx
|
pyvlx/alias_array.py
|
AliasArray.parse_raw
|
def parse_raw(self, raw):
"""Parse alias array from raw bytes."""
if not isinstance(raw, bytes):
raise PyVLXException("AliasArray::invalid_type_if_raw", type_raw=type(raw))
if len(raw) != 21:
raise PyVLXException("AliasArray::invalid_size", size=len(raw))
nbr_of_alias = raw[0]
if nbr_of_alias > 5:
raise PyVLXException("AliasArray::invalid_nbr_of_alias", nbr_of_alias=nbr_of_alias)
for i in range(0, nbr_of_alias):
self.alias_array_.append((raw[i*4+1:i*4+3], raw[i*4+3:i*4+5]))
|
python
|
def parse_raw(self, raw):
"""Parse alias array from raw bytes."""
if not isinstance(raw, bytes):
raise PyVLXException("AliasArray::invalid_type_if_raw", type_raw=type(raw))
if len(raw) != 21:
raise PyVLXException("AliasArray::invalid_size", size=len(raw))
nbr_of_alias = raw[0]
if nbr_of_alias > 5:
raise PyVLXException("AliasArray::invalid_nbr_of_alias", nbr_of_alias=nbr_of_alias)
for i in range(0, nbr_of_alias):
self.alias_array_.append((raw[i*4+1:i*4+3], raw[i*4+3:i*4+5]))
|
[
"def",
"parse_raw",
"(",
"self",
",",
"raw",
")",
":",
"if",
"not",
"isinstance",
"(",
"raw",
",",
"bytes",
")",
":",
"raise",
"PyVLXException",
"(",
"\"AliasArray::invalid_type_if_raw\"",
",",
"type_raw",
"=",
"type",
"(",
"raw",
")",
")",
"if",
"len",
"(",
"raw",
")",
"!=",
"21",
":",
"raise",
"PyVLXException",
"(",
"\"AliasArray::invalid_size\"",
",",
"size",
"=",
"len",
"(",
"raw",
")",
")",
"nbr_of_alias",
"=",
"raw",
"[",
"0",
"]",
"if",
"nbr_of_alias",
">",
"5",
":",
"raise",
"PyVLXException",
"(",
"\"AliasArray::invalid_nbr_of_alias\"",
",",
"nbr_of_alias",
"=",
"nbr_of_alias",
")",
"for",
"i",
"in",
"range",
"(",
"0",
",",
"nbr_of_alias",
")",
":",
"self",
".",
"alias_array_",
".",
"append",
"(",
"(",
"raw",
"[",
"i",
"*",
"4",
"+",
"1",
":",
"i",
"*",
"4",
"+",
"3",
"]",
",",
"raw",
"[",
"i",
"*",
"4",
"+",
"3",
":",
"i",
"*",
"4",
"+",
"5",
"]",
")",
")"
] |
Parse alias array from raw bytes.
|
[
"Parse",
"alias",
"array",
"from",
"raw",
"bytes",
"."
] |
train
|
https://github.com/Julius2342/pyvlx/blob/ee78e1324bcb1be5b8d1a9d05ab5496b72eae848/pyvlx/alias_array.py#L26-L36
|
Julius2342/pyvlx
|
pyvlx/slip.py
|
decode
|
def decode(raw):
"""Decode SLIP message."""
return raw \
.replace(bytes([SLIP_ESC, SLIP_ESC_END]), bytes([SLIP_END])) \
.replace(bytes([SLIP_ESC, SLIP_ESC_ESC]), bytes([SLIP_ESC]))
|
python
|
def decode(raw):
"""Decode SLIP message."""
return raw \
.replace(bytes([SLIP_ESC, SLIP_ESC_END]), bytes([SLIP_END])) \
.replace(bytes([SLIP_ESC, SLIP_ESC_ESC]), bytes([SLIP_ESC]))
|
[
"def",
"decode",
"(",
"raw",
")",
":",
"return",
"raw",
".",
"replace",
"(",
"bytes",
"(",
"[",
"SLIP_ESC",
",",
"SLIP_ESC_END",
"]",
")",
",",
"bytes",
"(",
"[",
"SLIP_END",
"]",
")",
")",
".",
"replace",
"(",
"bytes",
"(",
"[",
"SLIP_ESC",
",",
"SLIP_ESC_ESC",
"]",
")",
",",
"bytes",
"(",
"[",
"SLIP_ESC",
"]",
")",
")"
] |
Decode SLIP message.
|
[
"Decode",
"SLIP",
"message",
"."
] |
train
|
https://github.com/Julius2342/pyvlx/blob/ee78e1324bcb1be5b8d1a9d05ab5496b72eae848/pyvlx/slip.py#L16-L20
|
Julius2342/pyvlx
|
pyvlx/slip.py
|
encode
|
def encode(raw):
"""Encode SLIP message."""
return raw \
.replace(bytes([SLIP_ESC]), bytes([SLIP_ESC, SLIP_ESC_ESC])) \
.replace(bytes([SLIP_END]), bytes([SLIP_ESC, SLIP_ESC_END]))
|
python
|
def encode(raw):
"""Encode SLIP message."""
return raw \
.replace(bytes([SLIP_ESC]), bytes([SLIP_ESC, SLIP_ESC_ESC])) \
.replace(bytes([SLIP_END]), bytes([SLIP_ESC, SLIP_ESC_END]))
|
[
"def",
"encode",
"(",
"raw",
")",
":",
"return",
"raw",
".",
"replace",
"(",
"bytes",
"(",
"[",
"SLIP_ESC",
"]",
")",
",",
"bytes",
"(",
"[",
"SLIP_ESC",
",",
"SLIP_ESC_ESC",
"]",
")",
")",
".",
"replace",
"(",
"bytes",
"(",
"[",
"SLIP_END",
"]",
")",
",",
"bytes",
"(",
"[",
"SLIP_ESC",
",",
"SLIP_ESC_END",
"]",
")",
")"
] |
Encode SLIP message.
|
[
"Encode",
"SLIP",
"message",
"."
] |
train
|
https://github.com/Julius2342/pyvlx/blob/ee78e1324bcb1be5b8d1a9d05ab5496b72eae848/pyvlx/slip.py#L23-L27
|
Julius2342/pyvlx
|
pyvlx/slip.py
|
get_next_slip
|
def get_next_slip(raw):
"""
Get the next slip packet from raw data.
Returns the extracted packet plus the raw data with the remaining data stream.
"""
if not is_slip(raw):
return None, raw
length = raw[1:].index(SLIP_END)
slip_packet = decode(raw[1:length+1])
new_raw = raw[length+2:]
return slip_packet, new_raw
|
python
|
def get_next_slip(raw):
"""
Get the next slip packet from raw data.
Returns the extracted packet plus the raw data with the remaining data stream.
"""
if not is_slip(raw):
return None, raw
length = raw[1:].index(SLIP_END)
slip_packet = decode(raw[1:length+1])
new_raw = raw[length+2:]
return slip_packet, new_raw
|
[
"def",
"get_next_slip",
"(",
"raw",
")",
":",
"if",
"not",
"is_slip",
"(",
"raw",
")",
":",
"return",
"None",
",",
"raw",
"length",
"=",
"raw",
"[",
"1",
":",
"]",
".",
"index",
"(",
"SLIP_END",
")",
"slip_packet",
"=",
"decode",
"(",
"raw",
"[",
"1",
":",
"length",
"+",
"1",
"]",
")",
"new_raw",
"=",
"raw",
"[",
"length",
"+",
"2",
":",
"]",
"return",
"slip_packet",
",",
"new_raw"
] |
Get the next slip packet from raw data.
Returns the extracted packet plus the raw data with the remaining data stream.
|
[
"Get",
"the",
"next",
"slip",
"packet",
"from",
"raw",
"data",
"."
] |
train
|
https://github.com/Julius2342/pyvlx/blob/ee78e1324bcb1be5b8d1a9d05ab5496b72eae848/pyvlx/slip.py#L30-L41
|
Julius2342/pyvlx
|
pyvlx/set_utc.py
|
set_utc
|
async def set_utc(pyvlx):
"""Enable house status monitor."""
setutc = SetUTC(pyvlx=pyvlx)
await setutc.do_api_call()
if not setutc.success:
raise PyVLXException("Unable to set utc.")
|
python
|
async def set_utc(pyvlx):
"""Enable house status monitor."""
setutc = SetUTC(pyvlx=pyvlx)
await setutc.do_api_call()
if not setutc.success:
raise PyVLXException("Unable to set utc.")
|
[
"async",
"def",
"set_utc",
"(",
"pyvlx",
")",
":",
"setutc",
"=",
"SetUTC",
"(",
"pyvlx",
"=",
"pyvlx",
")",
"await",
"setutc",
".",
"do_api_call",
"(",
")",
"if",
"not",
"setutc",
".",
"success",
":",
"raise",
"PyVLXException",
"(",
"\"Unable to set utc.\"",
")"
] |
Enable house status monitor.
|
[
"Enable",
"house",
"status",
"monitor",
"."
] |
train
|
https://github.com/Julius2342/pyvlx/blob/ee78e1324bcb1be5b8d1a9d05ab5496b72eae848/pyvlx/set_utc.py#L30-L35
|
Julius2342/pyvlx
|
pyvlx/set_utc.py
|
SetUTC.handle_frame
|
async def handle_frame(self, frame):
"""Handle incoming API frame, return True if this was the expected frame."""
if not isinstance(frame, FrameSetUTCConfirmation):
return False
self.success = True
return True
|
python
|
async def handle_frame(self, frame):
"""Handle incoming API frame, return True if this was the expected frame."""
if not isinstance(frame, FrameSetUTCConfirmation):
return False
self.success = True
return True
|
[
"async",
"def",
"handle_frame",
"(",
"self",
",",
"frame",
")",
":",
"if",
"not",
"isinstance",
"(",
"frame",
",",
"FrameSetUTCConfirmation",
")",
":",
"return",
"False",
"self",
".",
"success",
"=",
"True",
"return",
"True"
] |
Handle incoming API frame, return True if this was the expected frame.
|
[
"Handle",
"incoming",
"API",
"frame",
"return",
"True",
"if",
"this",
"was",
"the",
"expected",
"frame",
"."
] |
train
|
https://github.com/Julius2342/pyvlx/blob/ee78e1324bcb1be5b8d1a9d05ab5496b72eae848/pyvlx/set_utc.py#L17-L22
|
spacetelescope/synphot_refactor
|
synphot/binning.py
|
_slow_calcbinflux
|
def _slow_calcbinflux(len_binwave, i_beg, i_end, avflux, deltaw):
"""Python implementation of ``calcbinflux``.
This is only used if ``synphot.synphot_utils`` C-extension
import fails.
See docstrings.py
"""
binflux = np.empty(shape=(len_binwave, ), dtype=np.float64)
intwave = np.empty(shape=(len_binwave, ), dtype=np.float64)
# Note that, like all Python striding, the range over which
# we integrate is [first:last).
for i in range(len(i_beg)):
first = i_beg[i]
last = i_end[i]
cur_dw = deltaw[first:last]
intwave[i] = cur_dw.sum()
binflux[i] = np.sum(avflux[first:last] * cur_dw) / intwave[i]
return binflux, intwave
|
python
|
def _slow_calcbinflux(len_binwave, i_beg, i_end, avflux, deltaw):
"""Python implementation of ``calcbinflux``.
This is only used if ``synphot.synphot_utils`` C-extension
import fails.
See docstrings.py
"""
binflux = np.empty(shape=(len_binwave, ), dtype=np.float64)
intwave = np.empty(shape=(len_binwave, ), dtype=np.float64)
# Note that, like all Python striding, the range over which
# we integrate is [first:last).
for i in range(len(i_beg)):
first = i_beg[i]
last = i_end[i]
cur_dw = deltaw[first:last]
intwave[i] = cur_dw.sum()
binflux[i] = np.sum(avflux[first:last] * cur_dw) / intwave[i]
return binflux, intwave
|
[
"def",
"_slow_calcbinflux",
"(",
"len_binwave",
",",
"i_beg",
",",
"i_end",
",",
"avflux",
",",
"deltaw",
")",
":",
"binflux",
"=",
"np",
".",
"empty",
"(",
"shape",
"=",
"(",
"len_binwave",
",",
")",
",",
"dtype",
"=",
"np",
".",
"float64",
")",
"intwave",
"=",
"np",
".",
"empty",
"(",
"shape",
"=",
"(",
"len_binwave",
",",
")",
",",
"dtype",
"=",
"np",
".",
"float64",
")",
"# Note that, like all Python striding, the range over which",
"# we integrate is [first:last).",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"i_beg",
")",
")",
":",
"first",
"=",
"i_beg",
"[",
"i",
"]",
"last",
"=",
"i_end",
"[",
"i",
"]",
"cur_dw",
"=",
"deltaw",
"[",
"first",
":",
"last",
"]",
"intwave",
"[",
"i",
"]",
"=",
"cur_dw",
".",
"sum",
"(",
")",
"binflux",
"[",
"i",
"]",
"=",
"np",
".",
"sum",
"(",
"avflux",
"[",
"first",
":",
"last",
"]",
"*",
"cur_dw",
")",
"/",
"intwave",
"[",
"i",
"]",
"return",
"binflux",
",",
"intwave"
] |
Python implementation of ``calcbinflux``.
This is only used if ``synphot.synphot_utils`` C-extension
import fails.
See docstrings.py
|
[
"Python",
"implementation",
"of",
"calcbinflux",
"."
] |
train
|
https://github.com/spacetelescope/synphot_refactor/blob/9c064f3cff0c41dd8acadc0f67c6350931275b9f/synphot/binning.py#L17-L38
|
spacetelescope/synphot_refactor
|
synphot/binning.py
|
calculate_bin_edges
|
def calculate_bin_edges(centers):
"""Calculate the edges of wavelength bins given the centers.
The algorithm calculates bin edges as the midpoints between bin centers
and treats the first and last bins as symmetric about their centers.
Parameters
----------
centers : array-like or `~astropy.units.quantity.Quantity`
Sequence of bin centers. Must be 1D and have at least two values.
If not a Quantity, assumed to be in Angstrom.
Returns
-------
edges : `~astropy.units.quantity.Quantity`
Array of bin edges. Will be 1D, have one more value
than ``centers``, and also the same unit.
Raises
------
synphot.exceptions.SynphotError
Invalid input.
"""
if not isinstance(centers, u.Quantity):
centers = centers * u.AA
if centers.ndim != 1:
raise exceptions.SynphotError('Bin centers must be 1D array.')
if centers.size < 2:
raise exceptions.SynphotError(
'Bin centers must have at least two values.')
edges = np.empty(centers.size + 1, dtype=np.float64)
edges[1:-1] = (centers.value[1:] + centers.value[:-1]) * 0.5
# Compute the first and last by making them symmetric
edges[0] = 2.0 * centers.value[0] - edges[1]
edges[-1] = 2.0 * centers.value[-1] - edges[-2]
return edges * centers.unit
|
python
|
def calculate_bin_edges(centers):
"""Calculate the edges of wavelength bins given the centers.
The algorithm calculates bin edges as the midpoints between bin centers
and treats the first and last bins as symmetric about their centers.
Parameters
----------
centers : array-like or `~astropy.units.quantity.Quantity`
Sequence of bin centers. Must be 1D and have at least two values.
If not a Quantity, assumed to be in Angstrom.
Returns
-------
edges : `~astropy.units.quantity.Quantity`
Array of bin edges. Will be 1D, have one more value
than ``centers``, and also the same unit.
Raises
------
synphot.exceptions.SynphotError
Invalid input.
"""
if not isinstance(centers, u.Quantity):
centers = centers * u.AA
if centers.ndim != 1:
raise exceptions.SynphotError('Bin centers must be 1D array.')
if centers.size < 2:
raise exceptions.SynphotError(
'Bin centers must have at least two values.')
edges = np.empty(centers.size + 1, dtype=np.float64)
edges[1:-1] = (centers.value[1:] + centers.value[:-1]) * 0.5
# Compute the first and last by making them symmetric
edges[0] = 2.0 * centers.value[0] - edges[1]
edges[-1] = 2.0 * centers.value[-1] - edges[-2]
return edges * centers.unit
|
[
"def",
"calculate_bin_edges",
"(",
"centers",
")",
":",
"if",
"not",
"isinstance",
"(",
"centers",
",",
"u",
".",
"Quantity",
")",
":",
"centers",
"=",
"centers",
"*",
"u",
".",
"AA",
"if",
"centers",
".",
"ndim",
"!=",
"1",
":",
"raise",
"exceptions",
".",
"SynphotError",
"(",
"'Bin centers must be 1D array.'",
")",
"if",
"centers",
".",
"size",
"<",
"2",
":",
"raise",
"exceptions",
".",
"SynphotError",
"(",
"'Bin centers must have at least two values.'",
")",
"edges",
"=",
"np",
".",
"empty",
"(",
"centers",
".",
"size",
"+",
"1",
",",
"dtype",
"=",
"np",
".",
"float64",
")",
"edges",
"[",
"1",
":",
"-",
"1",
"]",
"=",
"(",
"centers",
".",
"value",
"[",
"1",
":",
"]",
"+",
"centers",
".",
"value",
"[",
":",
"-",
"1",
"]",
")",
"*",
"0.5",
"# Compute the first and last by making them symmetric",
"edges",
"[",
"0",
"]",
"=",
"2.0",
"*",
"centers",
".",
"value",
"[",
"0",
"]",
"-",
"edges",
"[",
"1",
"]",
"edges",
"[",
"-",
"1",
"]",
"=",
"2.0",
"*",
"centers",
".",
"value",
"[",
"-",
"1",
"]",
"-",
"edges",
"[",
"-",
"2",
"]",
"return",
"edges",
"*",
"centers",
".",
"unit"
] |
Calculate the edges of wavelength bins given the centers.
The algorithm calculates bin edges as the midpoints between bin centers
and treats the first and last bins as symmetric about their centers.
Parameters
----------
centers : array-like or `~astropy.units.quantity.Quantity`
Sequence of bin centers. Must be 1D and have at least two values.
If not a Quantity, assumed to be in Angstrom.
Returns
-------
edges : `~astropy.units.quantity.Quantity`
Array of bin edges. Will be 1D, have one more value
than ``centers``, and also the same unit.
Raises
------
synphot.exceptions.SynphotError
Invalid input.
|
[
"Calculate",
"the",
"edges",
"of",
"wavelength",
"bins",
"given",
"the",
"centers",
"."
] |
train
|
https://github.com/spacetelescope/synphot_refactor/blob/9c064f3cff0c41dd8acadc0f67c6350931275b9f/synphot/binning.py#L51-L92
|
spacetelescope/synphot_refactor
|
synphot/binning.py
|
calculate_bin_widths
|
def calculate_bin_widths(edges):
"""Calculate the widths of wavelengths bins given their edges.
Parameters
----------
edges : array-like or `~astropy.units.quantity.Quantity`
Sequence of bin edges. Must be 1D and have at least two values.
If not a Quantity, assumed to be in Angstrom.
Returns
-------
widths : `~astropy.units.quantity.Quantity`
Array of bin widths. Will be 1D, have one less value
than ``edges``, and also the same unit.
Raises
------
synphot.exceptions.SynphotError
Invalid input.
"""
if not isinstance(edges, u.Quantity):
edges = edges * u.AA
if edges.ndim != 1:
raise exceptions.SynphotError('Bin edges must be 1D array.')
if edges.size < 2:
raise exceptions.SynphotError(
'Bin edges must have at least two values.')
return np.abs(edges[1:] - edges[:-1])
|
python
|
def calculate_bin_widths(edges):
"""Calculate the widths of wavelengths bins given their edges.
Parameters
----------
edges : array-like or `~astropy.units.quantity.Quantity`
Sequence of bin edges. Must be 1D and have at least two values.
If not a Quantity, assumed to be in Angstrom.
Returns
-------
widths : `~astropy.units.quantity.Quantity`
Array of bin widths. Will be 1D, have one less value
than ``edges``, and also the same unit.
Raises
------
synphot.exceptions.SynphotError
Invalid input.
"""
if not isinstance(edges, u.Quantity):
edges = edges * u.AA
if edges.ndim != 1:
raise exceptions.SynphotError('Bin edges must be 1D array.')
if edges.size < 2:
raise exceptions.SynphotError(
'Bin edges must have at least two values.')
return np.abs(edges[1:] - edges[:-1])
|
[
"def",
"calculate_bin_widths",
"(",
"edges",
")",
":",
"if",
"not",
"isinstance",
"(",
"edges",
",",
"u",
".",
"Quantity",
")",
":",
"edges",
"=",
"edges",
"*",
"u",
".",
"AA",
"if",
"edges",
".",
"ndim",
"!=",
"1",
":",
"raise",
"exceptions",
".",
"SynphotError",
"(",
"'Bin edges must be 1D array.'",
")",
"if",
"edges",
".",
"size",
"<",
"2",
":",
"raise",
"exceptions",
".",
"SynphotError",
"(",
"'Bin edges must have at least two values.'",
")",
"return",
"np",
".",
"abs",
"(",
"edges",
"[",
"1",
":",
"]",
"-",
"edges",
"[",
":",
"-",
"1",
"]",
")"
] |
Calculate the widths of wavelengths bins given their edges.
Parameters
----------
edges : array-like or `~astropy.units.quantity.Quantity`
Sequence of bin edges. Must be 1D and have at least two values.
If not a Quantity, assumed to be in Angstrom.
Returns
-------
widths : `~astropy.units.quantity.Quantity`
Array of bin widths. Will be 1D, have one less value
than ``edges``, and also the same unit.
Raises
------
synphot.exceptions.SynphotError
Invalid input.
|
[
"Calculate",
"the",
"widths",
"of",
"wavelengths",
"bins",
"given",
"their",
"edges",
"."
] |
train
|
https://github.com/spacetelescope/synphot_refactor/blob/9c064f3cff0c41dd8acadc0f67c6350931275b9f/synphot/binning.py#L95-L126
|
spacetelescope/synphot_refactor
|
synphot/binning.py
|
calculate_bin_centers
|
def calculate_bin_centers(edges):
"""Calculate the centers of wavelengths bins given their edges.
Parameters
----------
edges : array-like or `~astropy.units.quantity.Quantity`
Sequence of bin edges. Must be 1D and have at least two values.
If not a Quantity, assumed to be in Angstrom.
Returns
-------
centers : `~astropy.units.quantity.Quantity`
Array of bin centers. Will be 1D, have one less value
than ``edges``, and also the same unit.
Raises
------
synphot.exceptions.SynphotError
Invalid input.
"""
if not isinstance(edges, u.Quantity):
edges = edges * u.AA
if edges.ndim != 1:
raise exceptions.SynphotError('Bin edges must be 1D array.')
if edges.size < 2:
raise exceptions.SynphotError(
'Bin edges must have at least two values.')
centers = np.empty(edges.size - 1, dtype=np.float64)
centers[0] = edges.value[:2].mean()
for i in range(1, centers.size):
centers[i] = 2.0 * edges.value[i] - centers[i - 1]
return centers * edges.unit
|
python
|
def calculate_bin_centers(edges):
"""Calculate the centers of wavelengths bins given their edges.
Parameters
----------
edges : array-like or `~astropy.units.quantity.Quantity`
Sequence of bin edges. Must be 1D and have at least two values.
If not a Quantity, assumed to be in Angstrom.
Returns
-------
centers : `~astropy.units.quantity.Quantity`
Array of bin centers. Will be 1D, have one less value
than ``edges``, and also the same unit.
Raises
------
synphot.exceptions.SynphotError
Invalid input.
"""
if not isinstance(edges, u.Quantity):
edges = edges * u.AA
if edges.ndim != 1:
raise exceptions.SynphotError('Bin edges must be 1D array.')
if edges.size < 2:
raise exceptions.SynphotError(
'Bin edges must have at least two values.')
centers = np.empty(edges.size - 1, dtype=np.float64)
centers[0] = edges.value[:2].mean()
for i in range(1, centers.size):
centers[i] = 2.0 * edges.value[i] - centers[i - 1]
return centers * edges.unit
|
[
"def",
"calculate_bin_centers",
"(",
"edges",
")",
":",
"if",
"not",
"isinstance",
"(",
"edges",
",",
"u",
".",
"Quantity",
")",
":",
"edges",
"=",
"edges",
"*",
"u",
".",
"AA",
"if",
"edges",
".",
"ndim",
"!=",
"1",
":",
"raise",
"exceptions",
".",
"SynphotError",
"(",
"'Bin edges must be 1D array.'",
")",
"if",
"edges",
".",
"size",
"<",
"2",
":",
"raise",
"exceptions",
".",
"SynphotError",
"(",
"'Bin edges must have at least two values.'",
")",
"centers",
"=",
"np",
".",
"empty",
"(",
"edges",
".",
"size",
"-",
"1",
",",
"dtype",
"=",
"np",
".",
"float64",
")",
"centers",
"[",
"0",
"]",
"=",
"edges",
".",
"value",
"[",
":",
"2",
"]",
".",
"mean",
"(",
")",
"for",
"i",
"in",
"range",
"(",
"1",
",",
"centers",
".",
"size",
")",
":",
"centers",
"[",
"i",
"]",
"=",
"2.0",
"*",
"edges",
".",
"value",
"[",
"i",
"]",
"-",
"centers",
"[",
"i",
"-",
"1",
"]",
"return",
"centers",
"*",
"edges",
".",
"unit"
] |
Calculate the centers of wavelengths bins given their edges.
Parameters
----------
edges : array-like or `~astropy.units.quantity.Quantity`
Sequence of bin edges. Must be 1D and have at least two values.
If not a Quantity, assumed to be in Angstrom.
Returns
-------
centers : `~astropy.units.quantity.Quantity`
Array of bin centers. Will be 1D, have one less value
than ``edges``, and also the same unit.
Raises
------
synphot.exceptions.SynphotError
Invalid input.
|
[
"Calculate",
"the",
"centers",
"of",
"wavelengths",
"bins",
"given",
"their",
"edges",
"."
] |
train
|
https://github.com/spacetelescope/synphot_refactor/blob/9c064f3cff0c41dd8acadc0f67c6350931275b9f/synphot/binning.py#L129-L166
|
spacetelescope/synphot_refactor
|
synphot/binning.py
|
wave_range
|
def wave_range(bins, cenwave, npix, mode='round'):
"""Calculate the wavelength range covered by the given number of pixels
centered on the given central wavelength of the given bins.
Parameters
----------
bins : array-like
Wavelengths at bin centers, each centered on a pixel.
Must be 1D array.
cenwave : float
Desired central wavelength, in the same unit as ``bins``.
npix : int
Desired number of pixels, centered on ``cenwave``.
mode : {'round', 'min', 'max', 'none'}
Determines how the pixels at the edges of the wavelength range
are handled. All the options, except 'none', will return
wavelength range edges that correspond to pixel edges:
* 'round' - Wavelength range edges are the pixel edges
and the range spans exactly ``npix`` pixels. An edge
that falls in the center of a bin is rounded to the
nearest pixel edge. This is the default.
* 'min' - Wavelength range is shrunk such that it includes
an integer number of pixels and its edges fall on pixel
edges. It may not span exactly ``npix`` pixels.
* 'max' - Wavelength range is expanded such that it
includes an integer number of pixels and its edges fall
on pixel edges. It may not span exactly ``npix`` pixels.
* 'none' - Exact wavelength range is returned. The edges
may not correspond to pixel edges, but it covers exactly
``npix`` pixels.
Returns
-------
wave1, wave2 : float
Lower and upper limits of the wavelength range.
Raises
------
synphot.exceptions.OverlapError
Given central wavelength is not within the given bins
or the wavelength range would exceed the bin limits.
synphot.exceptions.SynphotError
Invalid inputs or calculation failed.
"""
mode = mode.lower()
if mode not in ('round', 'min', 'max', 'none'):
raise exceptions.SynphotError(
'mode={0} is invalid, must be "round", "min", "max", '
'or "none".'.format(mode))
if not isinstance(npix, int):
raise exceptions.SynphotError('npix={0} is invalid.'.format(npix))
# Bin values must be in ascending order.
if bins[0] > bins[-1]:
bins = bins[::-1]
# Central wavelength must be within given bins.
if cenwave < bins[0] or cenwave > bins[-1]:
raise exceptions.OverlapError(
'cenwave={0} is not within binset (min={1}, max={2}).'.format(
cenwave, bins[0], bins[-1]))
# Find the index the central wavelength among bins
diff = cenwave - bins
ind = np.argmin(np.abs(diff))
# Calculate fractional index
frac_ind = float(ind)
if diff[ind] < 0:
frac_ind += diff[ind] / (bins[ind] - bins[ind - 1])
elif diff[ind] > 0:
frac_ind += diff[ind] / (bins[ind + 1] - bins[ind])
# Calculate fractional indices of the edges
half_npix = npix / 2.0
frac_ind1 = frac_ind - half_npix
frac_ind2 = frac_ind + half_npix
# Calculated edges must not exceed bin edges
if frac_ind1 < -0.5:
raise exceptions.OverlapError(
'Lower limit of wavelength range is out of bounds.')
if frac_ind2 > (bins.size - 0.5):
raise exceptions.OverlapError(
'Upper limit of wavelength range is out of bounds.')
frac1, int1 = np.modf(frac_ind1)
frac2, int2 = np.modf(frac_ind2)
int1 = int(int1)
int2 = int(int2)
if mode == 'round':
# Lower end of wavelength range
if frac1 >= 0:
# end is somewhere greater than binset[0] so we can just
# interpolate between two neighboring values going with upper edge
wave1 = bins[int1:int1 + 2].mean()
else:
# end is below the lowest binset value, but not by enough to
# trigger an exception
wave1 = bins[0] - (bins[0:2].mean() - bins[0])
# Upper end of wavelength range
if int2 < bins.shape[0] - 1:
# end is somewhere below binset[-1] so we can just interpolate
# between two neighboring values, going with the upper edge.
wave2 = bins[int2:int2 + 2].mean()
else:
# end is above highest binset value but not by enough to
# trigger an exception
wave2 = bins[-1] + (bins[-1] - bins[-2:].mean())
elif mode == 'min':
# Lower end of wavelength range
if frac1 <= 0.5 and int1 < bins.shape[0] - 1:
# not at the lowest possible edge and pixel i included
wave1 = bins[int1:int1 + 2].mean()
elif frac1 > 0.5 and int1 < bins.shape[0] - 2:
# not at the lowest possible edge and pixel i not included
wave1 = bins[int1 + 1:int1 + 3].mean()
elif frac1 == -0.5:
# at the lowest possible edge
wave1 = bins[0] - (bins[0:2].mean() - bins[0])
else: # pragma: no cover
raise exceptions.SynphotError(
'mode={0} gets unexpected frac1={1}, int1={2}'.format(
mode, frac1, int1))
# Upper end of wavelength range
if frac2 >= 0.5 and int2 < bins.shape[0] - 1:
# not out at the end and pixel i included
wave2 = bins[int2:int2 + 2].mean()
elif frac2 < 0.5 and int2 < bins.shape[0]:
# not out at end and pixel i not included
wave2 = bins[int2 - 1:int2 + 1].mean()
elif frac2 == 0.5 and int2 == bins.shape[0] - 1:
# at the very end
wave2 = bins[-1] + (bins[-1] - bins[-2:].mean())
else: # pragma: no cover
raise exceptions.SynphotError(
'mode={0} gets unexpected frac2={1}, int2={2}'.format(
mode, frac2, int2))
elif mode == 'max':
# Lower end of wavelength range
if frac1 < 0.5 and int1 < bins.shape[0]:
# not at the lowest possible edge and pixel i included
wave1 = bins[int1 - 1:int1 + 1].mean()
elif frac1 >= 0.5 and int1 < bins.shape[0] - 1:
# not at the lowest possible edge and pixel i not included
wave1 = bins[int1:int1 + 2].mean()
elif frac1 == -0.5:
# at the lowest possible edge
wave1 = bins[0] - (bins[0:2].mean() - bins[0])
else: # pragma: no cover
raise exceptions.SynphotError(
'mode={0} gets unexpected frac1={1}, int1={2}'.format(
mode, frac1, int1))
# Upper end of wavelength range
if frac2 > 0.5 and int2 < bins.shape[0] - 2:
# not out at the end and pixel i included
wave2 = bins[int2 + 1:int2 + 3].mean()
elif frac2 <= 0.5 and int2 < bins.shape[0] - 1:
# not out at end and pixel i not included
wave2 = bins[int2:int2 + 2].mean()
elif frac2 == 0.5 and int2 == bins.shape[0] - 1:
# at the very end
wave2 = bins[-1] + (bins[-1] - bins[-2:].mean())
else: # pragma: no cover
raise exceptions.SynphotError(
'mode={0} gets unexpected frac2={1}, int2={2}'.format(
mode, frac2, int2))
else: # mode == 'none'
wave1 = bins[int1] + frac1 * (bins[int1 + 1] - bins[int1])
wave2 = bins[int2] + frac2 * (bins[int2 + 1] - bins[int2])
return wave1, wave2
|
python
|
def wave_range(bins, cenwave, npix, mode='round'):
"""Calculate the wavelength range covered by the given number of pixels
centered on the given central wavelength of the given bins.
Parameters
----------
bins : array-like
Wavelengths at bin centers, each centered on a pixel.
Must be 1D array.
cenwave : float
Desired central wavelength, in the same unit as ``bins``.
npix : int
Desired number of pixels, centered on ``cenwave``.
mode : {'round', 'min', 'max', 'none'}
Determines how the pixels at the edges of the wavelength range
are handled. All the options, except 'none', will return
wavelength range edges that correspond to pixel edges:
* 'round' - Wavelength range edges are the pixel edges
and the range spans exactly ``npix`` pixels. An edge
that falls in the center of a bin is rounded to the
nearest pixel edge. This is the default.
* 'min' - Wavelength range is shrunk such that it includes
an integer number of pixels and its edges fall on pixel
edges. It may not span exactly ``npix`` pixels.
* 'max' - Wavelength range is expanded such that it
includes an integer number of pixels and its edges fall
on pixel edges. It may not span exactly ``npix`` pixels.
* 'none' - Exact wavelength range is returned. The edges
may not correspond to pixel edges, but it covers exactly
``npix`` pixels.
Returns
-------
wave1, wave2 : float
Lower and upper limits of the wavelength range.
Raises
------
synphot.exceptions.OverlapError
Given central wavelength is not within the given bins
or the wavelength range would exceed the bin limits.
synphot.exceptions.SynphotError
Invalid inputs or calculation failed.
"""
mode = mode.lower()
if mode not in ('round', 'min', 'max', 'none'):
raise exceptions.SynphotError(
'mode={0} is invalid, must be "round", "min", "max", '
'or "none".'.format(mode))
if not isinstance(npix, int):
raise exceptions.SynphotError('npix={0} is invalid.'.format(npix))
# Bin values must be in ascending order.
if bins[0] > bins[-1]:
bins = bins[::-1]
# Central wavelength must be within given bins.
if cenwave < bins[0] or cenwave > bins[-1]:
raise exceptions.OverlapError(
'cenwave={0} is not within binset (min={1}, max={2}).'.format(
cenwave, bins[0], bins[-1]))
# Find the index the central wavelength among bins
diff = cenwave - bins
ind = np.argmin(np.abs(diff))
# Calculate fractional index
frac_ind = float(ind)
if diff[ind] < 0:
frac_ind += diff[ind] / (bins[ind] - bins[ind - 1])
elif diff[ind] > 0:
frac_ind += diff[ind] / (bins[ind + 1] - bins[ind])
# Calculate fractional indices of the edges
half_npix = npix / 2.0
frac_ind1 = frac_ind - half_npix
frac_ind2 = frac_ind + half_npix
# Calculated edges must not exceed bin edges
if frac_ind1 < -0.5:
raise exceptions.OverlapError(
'Lower limit of wavelength range is out of bounds.')
if frac_ind2 > (bins.size - 0.5):
raise exceptions.OverlapError(
'Upper limit of wavelength range is out of bounds.')
frac1, int1 = np.modf(frac_ind1)
frac2, int2 = np.modf(frac_ind2)
int1 = int(int1)
int2 = int(int2)
if mode == 'round':
# Lower end of wavelength range
if frac1 >= 0:
# end is somewhere greater than binset[0] so we can just
# interpolate between two neighboring values going with upper edge
wave1 = bins[int1:int1 + 2].mean()
else:
# end is below the lowest binset value, but not by enough to
# trigger an exception
wave1 = bins[0] - (bins[0:2].mean() - bins[0])
# Upper end of wavelength range
if int2 < bins.shape[0] - 1:
# end is somewhere below binset[-1] so we can just interpolate
# between two neighboring values, going with the upper edge.
wave2 = bins[int2:int2 + 2].mean()
else:
# end is above highest binset value but not by enough to
# trigger an exception
wave2 = bins[-1] + (bins[-1] - bins[-2:].mean())
elif mode == 'min':
# Lower end of wavelength range
if frac1 <= 0.5 and int1 < bins.shape[0] - 1:
# not at the lowest possible edge and pixel i included
wave1 = bins[int1:int1 + 2].mean()
elif frac1 > 0.5 and int1 < bins.shape[0] - 2:
# not at the lowest possible edge and pixel i not included
wave1 = bins[int1 + 1:int1 + 3].mean()
elif frac1 == -0.5:
# at the lowest possible edge
wave1 = bins[0] - (bins[0:2].mean() - bins[0])
else: # pragma: no cover
raise exceptions.SynphotError(
'mode={0} gets unexpected frac1={1}, int1={2}'.format(
mode, frac1, int1))
# Upper end of wavelength range
if frac2 >= 0.5 and int2 < bins.shape[0] - 1:
# not out at the end and pixel i included
wave2 = bins[int2:int2 + 2].mean()
elif frac2 < 0.5 and int2 < bins.shape[0]:
# not out at end and pixel i not included
wave2 = bins[int2 - 1:int2 + 1].mean()
elif frac2 == 0.5 and int2 == bins.shape[0] - 1:
# at the very end
wave2 = bins[-1] + (bins[-1] - bins[-2:].mean())
else: # pragma: no cover
raise exceptions.SynphotError(
'mode={0} gets unexpected frac2={1}, int2={2}'.format(
mode, frac2, int2))
elif mode == 'max':
# Lower end of wavelength range
if frac1 < 0.5 and int1 < bins.shape[0]:
# not at the lowest possible edge and pixel i included
wave1 = bins[int1 - 1:int1 + 1].mean()
elif frac1 >= 0.5 and int1 < bins.shape[0] - 1:
# not at the lowest possible edge and pixel i not included
wave1 = bins[int1:int1 + 2].mean()
elif frac1 == -0.5:
# at the lowest possible edge
wave1 = bins[0] - (bins[0:2].mean() - bins[0])
else: # pragma: no cover
raise exceptions.SynphotError(
'mode={0} gets unexpected frac1={1}, int1={2}'.format(
mode, frac1, int1))
# Upper end of wavelength range
if frac2 > 0.5 and int2 < bins.shape[0] - 2:
# not out at the end and pixel i included
wave2 = bins[int2 + 1:int2 + 3].mean()
elif frac2 <= 0.5 and int2 < bins.shape[0] - 1:
# not out at end and pixel i not included
wave2 = bins[int2:int2 + 2].mean()
elif frac2 == 0.5 and int2 == bins.shape[0] - 1:
# at the very end
wave2 = bins[-1] + (bins[-1] - bins[-2:].mean())
else: # pragma: no cover
raise exceptions.SynphotError(
'mode={0} gets unexpected frac2={1}, int2={2}'.format(
mode, frac2, int2))
else: # mode == 'none'
wave1 = bins[int1] + frac1 * (bins[int1 + 1] - bins[int1])
wave2 = bins[int2] + frac2 * (bins[int2 + 1] - bins[int2])
return wave1, wave2
|
[
"def",
"wave_range",
"(",
"bins",
",",
"cenwave",
",",
"npix",
",",
"mode",
"=",
"'round'",
")",
":",
"mode",
"=",
"mode",
".",
"lower",
"(",
")",
"if",
"mode",
"not",
"in",
"(",
"'round'",
",",
"'min'",
",",
"'max'",
",",
"'none'",
")",
":",
"raise",
"exceptions",
".",
"SynphotError",
"(",
"'mode={0} is invalid, must be \"round\", \"min\", \"max\", '",
"'or \"none\".'",
".",
"format",
"(",
"mode",
")",
")",
"if",
"not",
"isinstance",
"(",
"npix",
",",
"int",
")",
":",
"raise",
"exceptions",
".",
"SynphotError",
"(",
"'npix={0} is invalid.'",
".",
"format",
"(",
"npix",
")",
")",
"# Bin values must be in ascending order.",
"if",
"bins",
"[",
"0",
"]",
">",
"bins",
"[",
"-",
"1",
"]",
":",
"bins",
"=",
"bins",
"[",
":",
":",
"-",
"1",
"]",
"# Central wavelength must be within given bins.",
"if",
"cenwave",
"<",
"bins",
"[",
"0",
"]",
"or",
"cenwave",
">",
"bins",
"[",
"-",
"1",
"]",
":",
"raise",
"exceptions",
".",
"OverlapError",
"(",
"'cenwave={0} is not within binset (min={1}, max={2}).'",
".",
"format",
"(",
"cenwave",
",",
"bins",
"[",
"0",
"]",
",",
"bins",
"[",
"-",
"1",
"]",
")",
")",
"# Find the index the central wavelength among bins",
"diff",
"=",
"cenwave",
"-",
"bins",
"ind",
"=",
"np",
".",
"argmin",
"(",
"np",
".",
"abs",
"(",
"diff",
")",
")",
"# Calculate fractional index",
"frac_ind",
"=",
"float",
"(",
"ind",
")",
"if",
"diff",
"[",
"ind",
"]",
"<",
"0",
":",
"frac_ind",
"+=",
"diff",
"[",
"ind",
"]",
"/",
"(",
"bins",
"[",
"ind",
"]",
"-",
"bins",
"[",
"ind",
"-",
"1",
"]",
")",
"elif",
"diff",
"[",
"ind",
"]",
">",
"0",
":",
"frac_ind",
"+=",
"diff",
"[",
"ind",
"]",
"/",
"(",
"bins",
"[",
"ind",
"+",
"1",
"]",
"-",
"bins",
"[",
"ind",
"]",
")",
"# Calculate fractional indices of the edges",
"half_npix",
"=",
"npix",
"/",
"2.0",
"frac_ind1",
"=",
"frac_ind",
"-",
"half_npix",
"frac_ind2",
"=",
"frac_ind",
"+",
"half_npix",
"# Calculated edges must not exceed bin edges",
"if",
"frac_ind1",
"<",
"-",
"0.5",
":",
"raise",
"exceptions",
".",
"OverlapError",
"(",
"'Lower limit of wavelength range is out of bounds.'",
")",
"if",
"frac_ind2",
">",
"(",
"bins",
".",
"size",
"-",
"0.5",
")",
":",
"raise",
"exceptions",
".",
"OverlapError",
"(",
"'Upper limit of wavelength range is out of bounds.'",
")",
"frac1",
",",
"int1",
"=",
"np",
".",
"modf",
"(",
"frac_ind1",
")",
"frac2",
",",
"int2",
"=",
"np",
".",
"modf",
"(",
"frac_ind2",
")",
"int1",
"=",
"int",
"(",
"int1",
")",
"int2",
"=",
"int",
"(",
"int2",
")",
"if",
"mode",
"==",
"'round'",
":",
"# Lower end of wavelength range",
"if",
"frac1",
">=",
"0",
":",
"# end is somewhere greater than binset[0] so we can just",
"# interpolate between two neighboring values going with upper edge",
"wave1",
"=",
"bins",
"[",
"int1",
":",
"int1",
"+",
"2",
"]",
".",
"mean",
"(",
")",
"else",
":",
"# end is below the lowest binset value, but not by enough to",
"# trigger an exception",
"wave1",
"=",
"bins",
"[",
"0",
"]",
"-",
"(",
"bins",
"[",
"0",
":",
"2",
"]",
".",
"mean",
"(",
")",
"-",
"bins",
"[",
"0",
"]",
")",
"# Upper end of wavelength range",
"if",
"int2",
"<",
"bins",
".",
"shape",
"[",
"0",
"]",
"-",
"1",
":",
"# end is somewhere below binset[-1] so we can just interpolate",
"# between two neighboring values, going with the upper edge.",
"wave2",
"=",
"bins",
"[",
"int2",
":",
"int2",
"+",
"2",
"]",
".",
"mean",
"(",
")",
"else",
":",
"# end is above highest binset value but not by enough to",
"# trigger an exception",
"wave2",
"=",
"bins",
"[",
"-",
"1",
"]",
"+",
"(",
"bins",
"[",
"-",
"1",
"]",
"-",
"bins",
"[",
"-",
"2",
":",
"]",
".",
"mean",
"(",
")",
")",
"elif",
"mode",
"==",
"'min'",
":",
"# Lower end of wavelength range",
"if",
"frac1",
"<=",
"0.5",
"and",
"int1",
"<",
"bins",
".",
"shape",
"[",
"0",
"]",
"-",
"1",
":",
"# not at the lowest possible edge and pixel i included",
"wave1",
"=",
"bins",
"[",
"int1",
":",
"int1",
"+",
"2",
"]",
".",
"mean",
"(",
")",
"elif",
"frac1",
">",
"0.5",
"and",
"int1",
"<",
"bins",
".",
"shape",
"[",
"0",
"]",
"-",
"2",
":",
"# not at the lowest possible edge and pixel i not included",
"wave1",
"=",
"bins",
"[",
"int1",
"+",
"1",
":",
"int1",
"+",
"3",
"]",
".",
"mean",
"(",
")",
"elif",
"frac1",
"==",
"-",
"0.5",
":",
"# at the lowest possible edge",
"wave1",
"=",
"bins",
"[",
"0",
"]",
"-",
"(",
"bins",
"[",
"0",
":",
"2",
"]",
".",
"mean",
"(",
")",
"-",
"bins",
"[",
"0",
"]",
")",
"else",
":",
"# pragma: no cover",
"raise",
"exceptions",
".",
"SynphotError",
"(",
"'mode={0} gets unexpected frac1={1}, int1={2}'",
".",
"format",
"(",
"mode",
",",
"frac1",
",",
"int1",
")",
")",
"# Upper end of wavelength range",
"if",
"frac2",
">=",
"0.5",
"and",
"int2",
"<",
"bins",
".",
"shape",
"[",
"0",
"]",
"-",
"1",
":",
"# not out at the end and pixel i included",
"wave2",
"=",
"bins",
"[",
"int2",
":",
"int2",
"+",
"2",
"]",
".",
"mean",
"(",
")",
"elif",
"frac2",
"<",
"0.5",
"and",
"int2",
"<",
"bins",
".",
"shape",
"[",
"0",
"]",
":",
"# not out at end and pixel i not included",
"wave2",
"=",
"bins",
"[",
"int2",
"-",
"1",
":",
"int2",
"+",
"1",
"]",
".",
"mean",
"(",
")",
"elif",
"frac2",
"==",
"0.5",
"and",
"int2",
"==",
"bins",
".",
"shape",
"[",
"0",
"]",
"-",
"1",
":",
"# at the very end",
"wave2",
"=",
"bins",
"[",
"-",
"1",
"]",
"+",
"(",
"bins",
"[",
"-",
"1",
"]",
"-",
"bins",
"[",
"-",
"2",
":",
"]",
".",
"mean",
"(",
")",
")",
"else",
":",
"# pragma: no cover",
"raise",
"exceptions",
".",
"SynphotError",
"(",
"'mode={0} gets unexpected frac2={1}, int2={2}'",
".",
"format",
"(",
"mode",
",",
"frac2",
",",
"int2",
")",
")",
"elif",
"mode",
"==",
"'max'",
":",
"# Lower end of wavelength range",
"if",
"frac1",
"<",
"0.5",
"and",
"int1",
"<",
"bins",
".",
"shape",
"[",
"0",
"]",
":",
"# not at the lowest possible edge and pixel i included",
"wave1",
"=",
"bins",
"[",
"int1",
"-",
"1",
":",
"int1",
"+",
"1",
"]",
".",
"mean",
"(",
")",
"elif",
"frac1",
">=",
"0.5",
"and",
"int1",
"<",
"bins",
".",
"shape",
"[",
"0",
"]",
"-",
"1",
":",
"# not at the lowest possible edge and pixel i not included",
"wave1",
"=",
"bins",
"[",
"int1",
":",
"int1",
"+",
"2",
"]",
".",
"mean",
"(",
")",
"elif",
"frac1",
"==",
"-",
"0.5",
":",
"# at the lowest possible edge",
"wave1",
"=",
"bins",
"[",
"0",
"]",
"-",
"(",
"bins",
"[",
"0",
":",
"2",
"]",
".",
"mean",
"(",
")",
"-",
"bins",
"[",
"0",
"]",
")",
"else",
":",
"# pragma: no cover",
"raise",
"exceptions",
".",
"SynphotError",
"(",
"'mode={0} gets unexpected frac1={1}, int1={2}'",
".",
"format",
"(",
"mode",
",",
"frac1",
",",
"int1",
")",
")",
"# Upper end of wavelength range",
"if",
"frac2",
">",
"0.5",
"and",
"int2",
"<",
"bins",
".",
"shape",
"[",
"0",
"]",
"-",
"2",
":",
"# not out at the end and pixel i included",
"wave2",
"=",
"bins",
"[",
"int2",
"+",
"1",
":",
"int2",
"+",
"3",
"]",
".",
"mean",
"(",
")",
"elif",
"frac2",
"<=",
"0.5",
"and",
"int2",
"<",
"bins",
".",
"shape",
"[",
"0",
"]",
"-",
"1",
":",
"# not out at end and pixel i not included",
"wave2",
"=",
"bins",
"[",
"int2",
":",
"int2",
"+",
"2",
"]",
".",
"mean",
"(",
")",
"elif",
"frac2",
"==",
"0.5",
"and",
"int2",
"==",
"bins",
".",
"shape",
"[",
"0",
"]",
"-",
"1",
":",
"# at the very end",
"wave2",
"=",
"bins",
"[",
"-",
"1",
"]",
"+",
"(",
"bins",
"[",
"-",
"1",
"]",
"-",
"bins",
"[",
"-",
"2",
":",
"]",
".",
"mean",
"(",
")",
")",
"else",
":",
"# pragma: no cover",
"raise",
"exceptions",
".",
"SynphotError",
"(",
"'mode={0} gets unexpected frac2={1}, int2={2}'",
".",
"format",
"(",
"mode",
",",
"frac2",
",",
"int2",
")",
")",
"else",
":",
"# mode == 'none'",
"wave1",
"=",
"bins",
"[",
"int1",
"]",
"+",
"frac1",
"*",
"(",
"bins",
"[",
"int1",
"+",
"1",
"]",
"-",
"bins",
"[",
"int1",
"]",
")",
"wave2",
"=",
"bins",
"[",
"int2",
"]",
"+",
"frac2",
"*",
"(",
"bins",
"[",
"int2",
"+",
"1",
"]",
"-",
"bins",
"[",
"int2",
"]",
")",
"return",
"wave1",
",",
"wave2"
] |
Calculate the wavelength range covered by the given number of pixels
centered on the given central wavelength of the given bins.
Parameters
----------
bins : array-like
Wavelengths at bin centers, each centered on a pixel.
Must be 1D array.
cenwave : float
Desired central wavelength, in the same unit as ``bins``.
npix : int
Desired number of pixels, centered on ``cenwave``.
mode : {'round', 'min', 'max', 'none'}
Determines how the pixels at the edges of the wavelength range
are handled. All the options, except 'none', will return
wavelength range edges that correspond to pixel edges:
* 'round' - Wavelength range edges are the pixel edges
and the range spans exactly ``npix`` pixels. An edge
that falls in the center of a bin is rounded to the
nearest pixel edge. This is the default.
* 'min' - Wavelength range is shrunk such that it includes
an integer number of pixels and its edges fall on pixel
edges. It may not span exactly ``npix`` pixels.
* 'max' - Wavelength range is expanded such that it
includes an integer number of pixels and its edges fall
on pixel edges. It may not span exactly ``npix`` pixels.
* 'none' - Exact wavelength range is returned. The edges
may not correspond to pixel edges, but it covers exactly
``npix`` pixels.
Returns
-------
wave1, wave2 : float
Lower and upper limits of the wavelength range.
Raises
------
synphot.exceptions.OverlapError
Given central wavelength is not within the given bins
or the wavelength range would exceed the bin limits.
synphot.exceptions.SynphotError
Invalid inputs or calculation failed.
|
[
"Calculate",
"the",
"wavelength",
"range",
"covered",
"by",
"the",
"given",
"number",
"of",
"pixels",
"centered",
"on",
"the",
"given",
"central",
"wavelength",
"of",
"the",
"given",
"bins",
"."
] |
train
|
https://github.com/spacetelescope/synphot_refactor/blob/9c064f3cff0c41dd8acadc0f67c6350931275b9f/synphot/binning.py#L169-L358
|
spacetelescope/synphot_refactor
|
synphot/binning.py
|
pixel_range
|
def pixel_range(bins, waverange, mode='round'):
"""Calculate the number of pixels within the given wavelength range
and the given bins.
Parameters
----------
bins : array-like
Wavelengths at bin centers, each centered on a pixel.
Must be 1D array.
waverange : tuple of float
Lower and upper limits of the desired wavelength range,
in the same unit as ``bins``.
mode : {'round', 'min', 'max', 'none'}
Determines how the pixels at the edges of the wavelength range
are handled. All the options, except 'none', will return
an integer number of pixels:
* 'round' - Wavelength range edges that fall in the middle
of a pixel are counted if more than half of the pixel is
within the given wavelength range. Edges that fall in
the center of a pixel are rounded to the nearest pixel
edge. This is the default.
* 'min' - Only pixels wholly within the given wavelength
range are counted.
* 'max' - Pixels that are within the given wavelength range
by any margin are counted.
* 'none' - The exact number of encompassed pixels,
including fractional pixels, is returned.
Returns
-------
npix : number
Number of pixels.
Raises
------
synphot.exceptions.OverlapError
Given wavelength range exceeds the bounds of given bins.
synphot.exceptions.SynphotError
Invalid mode.
"""
mode = mode.lower()
if mode not in ('round', 'min', 'max', 'none'):
raise exceptions.SynphotError(
'mode={0} is invalid, must be "round", "min", "max", '
'or "none".'.format(mode))
if waverange[0] < waverange[-1]:
wave1 = waverange[0]
wave2 = waverange[-1]
else:
wave1 = waverange[-1]
wave2 = waverange[0]
# Bin values must be in ascending order.
if bins[0] > bins[-1]:
bins = bins[::-1]
# Wavelength range must be within bins
minwave = bins[0] - (bins[0:2].mean() - bins[0])
maxwave = bins[-1] + (bins[-1] - bins[-2:].mean())
if wave1 < minwave or wave2 > maxwave:
raise exceptions.OverlapError(
'Wavelength range ({0}, {1}) is out of bounds of bins '
'(min={2}, max={3}).'.format(wave1, wave2, minwave, maxwave))
if wave1 == wave2:
return 0
if mode == 'round':
ind1 = bins.searchsorted(wave1, side='right')
ind2 = bins.searchsorted(wave2, side='right')
else:
ind1 = bins.searchsorted(wave1, side='left')
ind2 = bins.searchsorted(wave2, side='left')
if mode == 'round':
npix = ind2 - ind1
elif mode == 'min':
# for ind1, figure out if pixel ind1 is wholly included or not.
# do this by figuring out where wave1 is between ind1 and ind1-1.
frac = (bins[ind1] - wave1) / (bins[ind1] - bins[ind1 - 1])
if frac < 0.5:
# ind1 is only partially included
ind1 += 1
# similar but reversed procedure for ind2
frac = (wave2 - bins[ind2 - 1]) / (bins[ind2] - bins[ind2 - 1])
if frac < 0.5:
# ind2 is only partially included
ind2 -= 1
npix = ind2 - ind1
elif mode == 'max':
# for ind1, figure out if pixel ind1-1 is partially included or not.
# do this by figuring out where wave1 is between ind1 and ind1-1.
frac = (wave1 - bins[ind1 - 1]) / (bins[ind1] - bins[ind1 - 1])
if frac < 0.5:
# ind1 is partially included
ind1 -= 1
# similar but reversed procedure for ind2
frac = (bins[ind2] - wave2) / (bins[ind2] - bins[ind2 - 1])
if frac < 0.5:
# ind2 is partially included
ind2 += 1
npix = ind2 - ind1
else: # mode == 'none'
# calculate fractional indices
frac1 = ind1 - (bins[ind1] - wave1) / (bins[ind1] - bins[ind1 - 1])
frac2 = ind2 - (bins[ind2] - wave2) / (bins[ind2] - bins[ind2 - 1])
npix = frac2 - frac1
return npix
|
python
|
def pixel_range(bins, waverange, mode='round'):
"""Calculate the number of pixels within the given wavelength range
and the given bins.
Parameters
----------
bins : array-like
Wavelengths at bin centers, each centered on a pixel.
Must be 1D array.
waverange : tuple of float
Lower and upper limits of the desired wavelength range,
in the same unit as ``bins``.
mode : {'round', 'min', 'max', 'none'}
Determines how the pixels at the edges of the wavelength range
are handled. All the options, except 'none', will return
an integer number of pixels:
* 'round' - Wavelength range edges that fall in the middle
of a pixel are counted if more than half of the pixel is
within the given wavelength range. Edges that fall in
the center of a pixel are rounded to the nearest pixel
edge. This is the default.
* 'min' - Only pixels wholly within the given wavelength
range are counted.
* 'max' - Pixels that are within the given wavelength range
by any margin are counted.
* 'none' - The exact number of encompassed pixels,
including fractional pixels, is returned.
Returns
-------
npix : number
Number of pixels.
Raises
------
synphot.exceptions.OverlapError
Given wavelength range exceeds the bounds of given bins.
synphot.exceptions.SynphotError
Invalid mode.
"""
mode = mode.lower()
if mode not in ('round', 'min', 'max', 'none'):
raise exceptions.SynphotError(
'mode={0} is invalid, must be "round", "min", "max", '
'or "none".'.format(mode))
if waverange[0] < waverange[-1]:
wave1 = waverange[0]
wave2 = waverange[-1]
else:
wave1 = waverange[-1]
wave2 = waverange[0]
# Bin values must be in ascending order.
if bins[0] > bins[-1]:
bins = bins[::-1]
# Wavelength range must be within bins
minwave = bins[0] - (bins[0:2].mean() - bins[0])
maxwave = bins[-1] + (bins[-1] - bins[-2:].mean())
if wave1 < minwave or wave2 > maxwave:
raise exceptions.OverlapError(
'Wavelength range ({0}, {1}) is out of bounds of bins '
'(min={2}, max={3}).'.format(wave1, wave2, minwave, maxwave))
if wave1 == wave2:
return 0
if mode == 'round':
ind1 = bins.searchsorted(wave1, side='right')
ind2 = bins.searchsorted(wave2, side='right')
else:
ind1 = bins.searchsorted(wave1, side='left')
ind2 = bins.searchsorted(wave2, side='left')
if mode == 'round':
npix = ind2 - ind1
elif mode == 'min':
# for ind1, figure out if pixel ind1 is wholly included or not.
# do this by figuring out where wave1 is between ind1 and ind1-1.
frac = (bins[ind1] - wave1) / (bins[ind1] - bins[ind1 - 1])
if frac < 0.5:
# ind1 is only partially included
ind1 += 1
# similar but reversed procedure for ind2
frac = (wave2 - bins[ind2 - 1]) / (bins[ind2] - bins[ind2 - 1])
if frac < 0.5:
# ind2 is only partially included
ind2 -= 1
npix = ind2 - ind1
elif mode == 'max':
# for ind1, figure out if pixel ind1-1 is partially included or not.
# do this by figuring out where wave1 is between ind1 and ind1-1.
frac = (wave1 - bins[ind1 - 1]) / (bins[ind1] - bins[ind1 - 1])
if frac < 0.5:
# ind1 is partially included
ind1 -= 1
# similar but reversed procedure for ind2
frac = (bins[ind2] - wave2) / (bins[ind2] - bins[ind2 - 1])
if frac < 0.5:
# ind2 is partially included
ind2 += 1
npix = ind2 - ind1
else: # mode == 'none'
# calculate fractional indices
frac1 = ind1 - (bins[ind1] - wave1) / (bins[ind1] - bins[ind1 - 1])
frac2 = ind2 - (bins[ind2] - wave2) / (bins[ind2] - bins[ind2 - 1])
npix = frac2 - frac1
return npix
|
[
"def",
"pixel_range",
"(",
"bins",
",",
"waverange",
",",
"mode",
"=",
"'round'",
")",
":",
"mode",
"=",
"mode",
".",
"lower",
"(",
")",
"if",
"mode",
"not",
"in",
"(",
"'round'",
",",
"'min'",
",",
"'max'",
",",
"'none'",
")",
":",
"raise",
"exceptions",
".",
"SynphotError",
"(",
"'mode={0} is invalid, must be \"round\", \"min\", \"max\", '",
"'or \"none\".'",
".",
"format",
"(",
"mode",
")",
")",
"if",
"waverange",
"[",
"0",
"]",
"<",
"waverange",
"[",
"-",
"1",
"]",
":",
"wave1",
"=",
"waverange",
"[",
"0",
"]",
"wave2",
"=",
"waverange",
"[",
"-",
"1",
"]",
"else",
":",
"wave1",
"=",
"waverange",
"[",
"-",
"1",
"]",
"wave2",
"=",
"waverange",
"[",
"0",
"]",
"# Bin values must be in ascending order.",
"if",
"bins",
"[",
"0",
"]",
">",
"bins",
"[",
"-",
"1",
"]",
":",
"bins",
"=",
"bins",
"[",
":",
":",
"-",
"1",
"]",
"# Wavelength range must be within bins",
"minwave",
"=",
"bins",
"[",
"0",
"]",
"-",
"(",
"bins",
"[",
"0",
":",
"2",
"]",
".",
"mean",
"(",
")",
"-",
"bins",
"[",
"0",
"]",
")",
"maxwave",
"=",
"bins",
"[",
"-",
"1",
"]",
"+",
"(",
"bins",
"[",
"-",
"1",
"]",
"-",
"bins",
"[",
"-",
"2",
":",
"]",
".",
"mean",
"(",
")",
")",
"if",
"wave1",
"<",
"minwave",
"or",
"wave2",
">",
"maxwave",
":",
"raise",
"exceptions",
".",
"OverlapError",
"(",
"'Wavelength range ({0}, {1}) is out of bounds of bins '",
"'(min={2}, max={3}).'",
".",
"format",
"(",
"wave1",
",",
"wave2",
",",
"minwave",
",",
"maxwave",
")",
")",
"if",
"wave1",
"==",
"wave2",
":",
"return",
"0",
"if",
"mode",
"==",
"'round'",
":",
"ind1",
"=",
"bins",
".",
"searchsorted",
"(",
"wave1",
",",
"side",
"=",
"'right'",
")",
"ind2",
"=",
"bins",
".",
"searchsorted",
"(",
"wave2",
",",
"side",
"=",
"'right'",
")",
"else",
":",
"ind1",
"=",
"bins",
".",
"searchsorted",
"(",
"wave1",
",",
"side",
"=",
"'left'",
")",
"ind2",
"=",
"bins",
".",
"searchsorted",
"(",
"wave2",
",",
"side",
"=",
"'left'",
")",
"if",
"mode",
"==",
"'round'",
":",
"npix",
"=",
"ind2",
"-",
"ind1",
"elif",
"mode",
"==",
"'min'",
":",
"# for ind1, figure out if pixel ind1 is wholly included or not.",
"# do this by figuring out where wave1 is between ind1 and ind1-1.",
"frac",
"=",
"(",
"bins",
"[",
"ind1",
"]",
"-",
"wave1",
")",
"/",
"(",
"bins",
"[",
"ind1",
"]",
"-",
"bins",
"[",
"ind1",
"-",
"1",
"]",
")",
"if",
"frac",
"<",
"0.5",
":",
"# ind1 is only partially included",
"ind1",
"+=",
"1",
"# similar but reversed procedure for ind2",
"frac",
"=",
"(",
"wave2",
"-",
"bins",
"[",
"ind2",
"-",
"1",
"]",
")",
"/",
"(",
"bins",
"[",
"ind2",
"]",
"-",
"bins",
"[",
"ind2",
"-",
"1",
"]",
")",
"if",
"frac",
"<",
"0.5",
":",
"# ind2 is only partially included",
"ind2",
"-=",
"1",
"npix",
"=",
"ind2",
"-",
"ind1",
"elif",
"mode",
"==",
"'max'",
":",
"# for ind1, figure out if pixel ind1-1 is partially included or not.",
"# do this by figuring out where wave1 is between ind1 and ind1-1.",
"frac",
"=",
"(",
"wave1",
"-",
"bins",
"[",
"ind1",
"-",
"1",
"]",
")",
"/",
"(",
"bins",
"[",
"ind1",
"]",
"-",
"bins",
"[",
"ind1",
"-",
"1",
"]",
")",
"if",
"frac",
"<",
"0.5",
":",
"# ind1 is partially included",
"ind1",
"-=",
"1",
"# similar but reversed procedure for ind2",
"frac",
"=",
"(",
"bins",
"[",
"ind2",
"]",
"-",
"wave2",
")",
"/",
"(",
"bins",
"[",
"ind2",
"]",
"-",
"bins",
"[",
"ind2",
"-",
"1",
"]",
")",
"if",
"frac",
"<",
"0.5",
":",
"# ind2 is partially included",
"ind2",
"+=",
"1",
"npix",
"=",
"ind2",
"-",
"ind1",
"else",
":",
"# mode == 'none'",
"# calculate fractional indices",
"frac1",
"=",
"ind1",
"-",
"(",
"bins",
"[",
"ind1",
"]",
"-",
"wave1",
")",
"/",
"(",
"bins",
"[",
"ind1",
"]",
"-",
"bins",
"[",
"ind1",
"-",
"1",
"]",
")",
"frac2",
"=",
"ind2",
"-",
"(",
"bins",
"[",
"ind2",
"]",
"-",
"wave2",
")",
"/",
"(",
"bins",
"[",
"ind2",
"]",
"-",
"bins",
"[",
"ind2",
"-",
"1",
"]",
")",
"npix",
"=",
"frac2",
"-",
"frac1",
"return",
"npix"
] |
Calculate the number of pixels within the given wavelength range
and the given bins.
Parameters
----------
bins : array-like
Wavelengths at bin centers, each centered on a pixel.
Must be 1D array.
waverange : tuple of float
Lower and upper limits of the desired wavelength range,
in the same unit as ``bins``.
mode : {'round', 'min', 'max', 'none'}
Determines how the pixels at the edges of the wavelength range
are handled. All the options, except 'none', will return
an integer number of pixels:
* 'round' - Wavelength range edges that fall in the middle
of a pixel are counted if more than half of the pixel is
within the given wavelength range. Edges that fall in
the center of a pixel are rounded to the nearest pixel
edge. This is the default.
* 'min' - Only pixels wholly within the given wavelength
range are counted.
* 'max' - Pixels that are within the given wavelength range
by any margin are counted.
* 'none' - The exact number of encompassed pixels,
including fractional pixels, is returned.
Returns
-------
npix : number
Number of pixels.
Raises
------
synphot.exceptions.OverlapError
Given wavelength range exceeds the bounds of given bins.
synphot.exceptions.SynphotError
Invalid mode.
|
[
"Calculate",
"the",
"number",
"of",
"pixels",
"within",
"the",
"given",
"wavelength",
"range",
"and",
"the",
"given",
"bins",
"."
] |
train
|
https://github.com/spacetelescope/synphot_refactor/blob/9c064f3cff0c41dd8acadc0f67c6350931275b9f/synphot/binning.py#L361-L486
|
Julius2342/pyvlx
|
pyvlx/pyvlx.py
|
PyVLX.connect
|
async def connect(self):
"""Connect to KLF 200."""
PYVLXLOG.warning("Connecting to KLF 200.")
await self.connection.connect()
login = Login(pyvlx=self, password=self.config.password)
await login.do_api_call()
if not login.success:
raise PyVLXException("Login to KLF 200 failed, check credentials")
|
python
|
async def connect(self):
"""Connect to KLF 200."""
PYVLXLOG.warning("Connecting to KLF 200.")
await self.connection.connect()
login = Login(pyvlx=self, password=self.config.password)
await login.do_api_call()
if not login.success:
raise PyVLXException("Login to KLF 200 failed, check credentials")
|
[
"async",
"def",
"connect",
"(",
"self",
")",
":",
"PYVLXLOG",
".",
"warning",
"(",
"\"Connecting to KLF 200.\"",
")",
"await",
"self",
".",
"connection",
".",
"connect",
"(",
")",
"login",
"=",
"Login",
"(",
"pyvlx",
"=",
"self",
",",
"password",
"=",
"self",
".",
"config",
".",
"password",
")",
"await",
"login",
".",
"do_api_call",
"(",
")",
"if",
"not",
"login",
".",
"success",
":",
"raise",
"PyVLXException",
"(",
"\"Login to KLF 200 failed, check credentials\"",
")"
] |
Connect to KLF 200.
|
[
"Connect",
"to",
"KLF",
"200",
"."
] |
train
|
https://github.com/Julius2342/pyvlx/blob/ee78e1324bcb1be5b8d1a9d05ab5496b72eae848/pyvlx/pyvlx.py#L42-L49
|
Julius2342/pyvlx
|
pyvlx/pyvlx.py
|
PyVLX.update_version
|
async def update_version(self):
"""Retrieve version and protocol version from API."""
get_version = GetVersion(pyvlx=self)
await get_version.do_api_call()
if not get_version.success:
raise PyVLXException("Unable to retrieve version")
self.version = get_version.version
get_protocol_version = GetProtocolVersion(pyvlx=self)
await get_protocol_version.do_api_call()
if not get_protocol_version.success:
raise PyVLXException("Unable to retrieve protocol version")
self.protocol_version = get_protocol_version.version
PYVLXLOG.warning(
"Connected to: %s, protocol version: %s",
self.version, self.protocol_version)
|
python
|
async def update_version(self):
"""Retrieve version and protocol version from API."""
get_version = GetVersion(pyvlx=self)
await get_version.do_api_call()
if not get_version.success:
raise PyVLXException("Unable to retrieve version")
self.version = get_version.version
get_protocol_version = GetProtocolVersion(pyvlx=self)
await get_protocol_version.do_api_call()
if not get_protocol_version.success:
raise PyVLXException("Unable to retrieve protocol version")
self.protocol_version = get_protocol_version.version
PYVLXLOG.warning(
"Connected to: %s, protocol version: %s",
self.version, self.protocol_version)
|
[
"async",
"def",
"update_version",
"(",
"self",
")",
":",
"get_version",
"=",
"GetVersion",
"(",
"pyvlx",
"=",
"self",
")",
"await",
"get_version",
".",
"do_api_call",
"(",
")",
"if",
"not",
"get_version",
".",
"success",
":",
"raise",
"PyVLXException",
"(",
"\"Unable to retrieve version\"",
")",
"self",
".",
"version",
"=",
"get_version",
".",
"version",
"get_protocol_version",
"=",
"GetProtocolVersion",
"(",
"pyvlx",
"=",
"self",
")",
"await",
"get_protocol_version",
".",
"do_api_call",
"(",
")",
"if",
"not",
"get_protocol_version",
".",
"success",
":",
"raise",
"PyVLXException",
"(",
"\"Unable to retrieve protocol version\"",
")",
"self",
".",
"protocol_version",
"=",
"get_protocol_version",
".",
"version",
"PYVLXLOG",
".",
"warning",
"(",
"\"Connected to: %s, protocol version: %s\"",
",",
"self",
".",
"version",
",",
"self",
".",
"protocol_version",
")"
] |
Retrieve version and protocol version from API.
|
[
"Retrieve",
"version",
"and",
"protocol",
"version",
"from",
"API",
"."
] |
train
|
https://github.com/Julius2342/pyvlx/blob/ee78e1324bcb1be5b8d1a9d05ab5496b72eae848/pyvlx/pyvlx.py#L51-L65
|
Julius2342/pyvlx
|
pyvlx/pyvlx.py
|
PyVLX.send_frame
|
async def send_frame(self, frame):
"""Send frame to API via connection."""
if not self.connection.connected:
await self.connect()
await self.update_version()
await set_utc(pyvlx=self)
await house_status_monitor_enable(pyvlx=self)
self.connection.write(frame)
|
python
|
async def send_frame(self, frame):
"""Send frame to API via connection."""
if not self.connection.connected:
await self.connect()
await self.update_version()
await set_utc(pyvlx=self)
await house_status_monitor_enable(pyvlx=self)
self.connection.write(frame)
|
[
"async",
"def",
"send_frame",
"(",
"self",
",",
"frame",
")",
":",
"if",
"not",
"self",
".",
"connection",
".",
"connected",
":",
"await",
"self",
".",
"connect",
"(",
")",
"await",
"self",
".",
"update_version",
"(",
")",
"await",
"set_utc",
"(",
"pyvlx",
"=",
"self",
")",
"await",
"house_status_monitor_enable",
"(",
"pyvlx",
"=",
"self",
")",
"self",
".",
"connection",
".",
"write",
"(",
"frame",
")"
] |
Send frame to API via connection.
|
[
"Send",
"frame",
"to",
"API",
"via",
"connection",
"."
] |
train
|
https://github.com/Julius2342/pyvlx/blob/ee78e1324bcb1be5b8d1a9d05ab5496b72eae848/pyvlx/pyvlx.py#L67-L74
|
Julius2342/pyvlx
|
old_api/pyvlx/scene.py
|
Scene.from_config
|
def from_config(cls, pyvlx, item):
"""Read scene from configuration."""
name = item['name']
ident = item['id']
return cls(pyvlx, ident, name)
|
python
|
def from_config(cls, pyvlx, item):
"""Read scene from configuration."""
name = item['name']
ident = item['id']
return cls(pyvlx, ident, name)
|
[
"def",
"from_config",
"(",
"cls",
",",
"pyvlx",
",",
"item",
")",
":",
"name",
"=",
"item",
"[",
"'name'",
"]",
"ident",
"=",
"item",
"[",
"'id'",
"]",
"return",
"cls",
"(",
"pyvlx",
",",
"ident",
",",
"name",
")"
] |
Read scene from configuration.
|
[
"Read",
"scene",
"from",
"configuration",
"."
] |
train
|
https://github.com/Julius2342/pyvlx/blob/ee78e1324bcb1be5b8d1a9d05ab5496b72eae848/old_api/pyvlx/scene.py#L14-L18
|
Julius2342/pyvlx
|
old_api/pyvlx/interface.py
|
Interface.api_call
|
async def api_call(self, verb, action, params=None, add_authorization_token=True, retry=False):
"""Send api call."""
if add_authorization_token and not self.token:
await self.refresh_token()
try:
return await self._api_call_impl(verb, action, params, add_authorization_token)
except InvalidToken:
if not retry and add_authorization_token:
await self.refresh_token()
# Recursive call of api_call
return await self.api_call(verb, action, params, add_authorization_token, True)
raise
|
python
|
async def api_call(self, verb, action, params=None, add_authorization_token=True, retry=False):
"""Send api call."""
if add_authorization_token and not self.token:
await self.refresh_token()
try:
return await self._api_call_impl(verb, action, params, add_authorization_token)
except InvalidToken:
if not retry and add_authorization_token:
await self.refresh_token()
# Recursive call of api_call
return await self.api_call(verb, action, params, add_authorization_token, True)
raise
|
[
"async",
"def",
"api_call",
"(",
"self",
",",
"verb",
",",
"action",
",",
"params",
"=",
"None",
",",
"add_authorization_token",
"=",
"True",
",",
"retry",
"=",
"False",
")",
":",
"if",
"add_authorization_token",
"and",
"not",
"self",
".",
"token",
":",
"await",
"self",
".",
"refresh_token",
"(",
")",
"try",
":",
"return",
"await",
"self",
".",
"_api_call_impl",
"(",
"verb",
",",
"action",
",",
"params",
",",
"add_authorization_token",
")",
"except",
"InvalidToken",
":",
"if",
"not",
"retry",
"and",
"add_authorization_token",
":",
"await",
"self",
".",
"refresh_token",
"(",
")",
"# Recursive call of api_call",
"return",
"await",
"self",
".",
"api_call",
"(",
"verb",
",",
"action",
",",
"params",
",",
"add_authorization_token",
",",
"True",
")",
"raise"
] |
Send api call.
|
[
"Send",
"api",
"call",
"."
] |
train
|
https://github.com/Julius2342/pyvlx/blob/ee78e1324bcb1be5b8d1a9d05ab5496b72eae848/old_api/pyvlx/interface.py#L19-L31
|
Julius2342/pyvlx
|
old_api/pyvlx/interface.py
|
Interface.refresh_token
|
async def refresh_token(self):
"""Refresh API token from KLF 200."""
json_response = await self.api_call('auth', 'login', {'password': self.config.password}, add_authorization_token=False)
if 'token' not in json_response:
raise PyVLXException('no element token found in response: {0}'.format(json.dumps(json_response)))
self.token = json_response['token']
|
python
|
async def refresh_token(self):
"""Refresh API token from KLF 200."""
json_response = await self.api_call('auth', 'login', {'password': self.config.password}, add_authorization_token=False)
if 'token' not in json_response:
raise PyVLXException('no element token found in response: {0}'.format(json.dumps(json_response)))
self.token = json_response['token']
|
[
"async",
"def",
"refresh_token",
"(",
"self",
")",
":",
"json_response",
"=",
"await",
"self",
".",
"api_call",
"(",
"'auth'",
",",
"'login'",
",",
"{",
"'password'",
":",
"self",
".",
"config",
".",
"password",
"}",
",",
"add_authorization_token",
"=",
"False",
")",
"if",
"'token'",
"not",
"in",
"json_response",
":",
"raise",
"PyVLXException",
"(",
"'no element token found in response: {0}'",
".",
"format",
"(",
"json",
".",
"dumps",
"(",
"json_response",
")",
")",
")",
"self",
".",
"token",
"=",
"json_response",
"[",
"'token'",
"]"
] |
Refresh API token from KLF 200.
|
[
"Refresh",
"API",
"token",
"from",
"KLF",
"200",
"."
] |
train
|
https://github.com/Julius2342/pyvlx/blob/ee78e1324bcb1be5b8d1a9d05ab5496b72eae848/old_api/pyvlx/interface.py#L62-L67
|
Julius2342/pyvlx
|
old_api/pyvlx/interface.py
|
Interface.create_body
|
def create_body(action, params):
"""Create http body for rest request."""
body = {}
body['action'] = action
if params is not None:
body['params'] = params
return body
|
python
|
def create_body(action, params):
"""Create http body for rest request."""
body = {}
body['action'] = action
if params is not None:
body['params'] = params
return body
|
[
"def",
"create_body",
"(",
"action",
",",
"params",
")",
":",
"body",
"=",
"{",
"}",
"body",
"[",
"'action'",
"]",
"=",
"action",
"if",
"params",
"is",
"not",
"None",
":",
"body",
"[",
"'params'",
"]",
"=",
"params",
"return",
"body"
] |
Create http body for rest request.
|
[
"Create",
"http",
"body",
"for",
"rest",
"request",
"."
] |
train
|
https://github.com/Julius2342/pyvlx/blob/ee78e1324bcb1be5b8d1a9d05ab5496b72eae848/old_api/pyvlx/interface.py#L89-L95
|
Julius2342/pyvlx
|
old_api/pyvlx/interface.py
|
Interface.evaluate_response
|
def evaluate_response(json_response):
"""Evaluate rest response."""
if 'errors' in json_response and json_response['errors']:
Interface.evaluate_errors(json_response)
elif 'result' not in json_response:
raise PyVLXException('no element result found in response: {0}'.format(json.dumps(json_response)))
elif not json_response['result']:
raise PyVLXException('Request failed {0}'.format(json.dumps(json_response)))
|
python
|
def evaluate_response(json_response):
"""Evaluate rest response."""
if 'errors' in json_response and json_response['errors']:
Interface.evaluate_errors(json_response)
elif 'result' not in json_response:
raise PyVLXException('no element result found in response: {0}'.format(json.dumps(json_response)))
elif not json_response['result']:
raise PyVLXException('Request failed {0}'.format(json.dumps(json_response)))
|
[
"def",
"evaluate_response",
"(",
"json_response",
")",
":",
"if",
"'errors'",
"in",
"json_response",
"and",
"json_response",
"[",
"'errors'",
"]",
":",
"Interface",
".",
"evaluate_errors",
"(",
"json_response",
")",
"elif",
"'result'",
"not",
"in",
"json_response",
":",
"raise",
"PyVLXException",
"(",
"'no element result found in response: {0}'",
".",
"format",
"(",
"json",
".",
"dumps",
"(",
"json_response",
")",
")",
")",
"elif",
"not",
"json_response",
"[",
"'result'",
"]",
":",
"raise",
"PyVLXException",
"(",
"'Request failed {0}'",
".",
"format",
"(",
"json",
".",
"dumps",
"(",
"json_response",
")",
")",
")"
] |
Evaluate rest response.
|
[
"Evaluate",
"rest",
"response",
"."
] |
train
|
https://github.com/Julius2342/pyvlx/blob/ee78e1324bcb1be5b8d1a9d05ab5496b72eae848/old_api/pyvlx/interface.py#L98-L105
|
Julius2342/pyvlx
|
old_api/pyvlx/interface.py
|
Interface.evaluate_errors
|
def evaluate_errors(json_response):
"""Evaluate rest errors."""
if 'errors' not in json_response or \
not isinstance(json_response['errors'], list) or \
not json_response['errors'] or \
not isinstance(json_response['errors'][0], int):
raise PyVLXException('Could not evaluate errors {0}'.format(json.dumps(json_response)))
# unclear if response may contain more errors than one. Taking the first.
first_error = json_response['errors'][0]
if first_error in [402, 403, 405, 406]:
raise InvalidToken(first_error)
raise PyVLXException('Unknown error code {0}'.format(first_error))
|
python
|
def evaluate_errors(json_response):
"""Evaluate rest errors."""
if 'errors' not in json_response or \
not isinstance(json_response['errors'], list) or \
not json_response['errors'] or \
not isinstance(json_response['errors'][0], int):
raise PyVLXException('Could not evaluate errors {0}'.format(json.dumps(json_response)))
# unclear if response may contain more errors than one. Taking the first.
first_error = json_response['errors'][0]
if first_error in [402, 403, 405, 406]:
raise InvalidToken(first_error)
raise PyVLXException('Unknown error code {0}'.format(first_error))
|
[
"def",
"evaluate_errors",
"(",
"json_response",
")",
":",
"if",
"'errors'",
"not",
"in",
"json_response",
"or",
"not",
"isinstance",
"(",
"json_response",
"[",
"'errors'",
"]",
",",
"list",
")",
"or",
"not",
"json_response",
"[",
"'errors'",
"]",
"or",
"not",
"isinstance",
"(",
"json_response",
"[",
"'errors'",
"]",
"[",
"0",
"]",
",",
"int",
")",
":",
"raise",
"PyVLXException",
"(",
"'Could not evaluate errors {0}'",
".",
"format",
"(",
"json",
".",
"dumps",
"(",
"json_response",
")",
")",
")",
"# unclear if response may contain more errors than one. Taking the first.",
"first_error",
"=",
"json_response",
"[",
"'errors'",
"]",
"[",
"0",
"]",
"if",
"first_error",
"in",
"[",
"402",
",",
"403",
",",
"405",
",",
"406",
"]",
":",
"raise",
"InvalidToken",
"(",
"first_error",
")",
"raise",
"PyVLXException",
"(",
"'Unknown error code {0}'",
".",
"format",
"(",
"first_error",
")",
")"
] |
Evaluate rest errors.
|
[
"Evaluate",
"rest",
"errors",
"."
] |
train
|
https://github.com/Julius2342/pyvlx/blob/ee78e1324bcb1be5b8d1a9d05ab5496b72eae848/old_api/pyvlx/interface.py#L108-L122
|
Julius2342/pyvlx
|
pyvlx/frames/frame_set_node_name.py
|
FrameSetNodeNameRequest.get_payload
|
def get_payload(self):
"""Return Payload."""
ret = bytes([self.node_id])
ret += string_to_bytes(self.name, 64)
return ret
|
python
|
def get_payload(self):
"""Return Payload."""
ret = bytes([self.node_id])
ret += string_to_bytes(self.name, 64)
return ret
|
[
"def",
"get_payload",
"(",
"self",
")",
":",
"ret",
"=",
"bytes",
"(",
"[",
"self",
".",
"node_id",
"]",
")",
"ret",
"+=",
"string_to_bytes",
"(",
"self",
".",
"name",
",",
"64",
")",
"return",
"ret"
] |
Return Payload.
|
[
"Return",
"Payload",
"."
] |
train
|
https://github.com/Julius2342/pyvlx/blob/ee78e1324bcb1be5b8d1a9d05ab5496b72eae848/pyvlx/frames/frame_set_node_name.py#L21-L25
|
Julius2342/pyvlx
|
pyvlx/frames/frame_set_node_name.py
|
FrameSetNodeNameRequest.from_payload
|
def from_payload(self, payload):
"""Init frame from binary data."""
self.node_id = payload[0]
self.name = bytes_to_string(payload[1:65])
|
python
|
def from_payload(self, payload):
"""Init frame from binary data."""
self.node_id = payload[0]
self.name = bytes_to_string(payload[1:65])
|
[
"def",
"from_payload",
"(",
"self",
",",
"payload",
")",
":",
"self",
".",
"node_id",
"=",
"payload",
"[",
"0",
"]",
"self",
".",
"name",
"=",
"bytes_to_string",
"(",
"payload",
"[",
"1",
":",
"65",
"]",
")"
] |
Init frame from binary data.
|
[
"Init",
"frame",
"from",
"binary",
"data",
"."
] |
train
|
https://github.com/Julius2342/pyvlx/blob/ee78e1324bcb1be5b8d1a9d05ab5496b72eae848/pyvlx/frames/frame_set_node_name.py#L27-L30
|
Julius2342/pyvlx
|
pyvlx/frames/frame_set_node_name.py
|
FrameSetNodeNameConfirmation.from_payload
|
def from_payload(self, payload):
"""Init frame from binary data."""
self.status = SetNodeNameConfirmationStatus(payload[0])
self.node_id = payload[1]
|
python
|
def from_payload(self, payload):
"""Init frame from binary data."""
self.status = SetNodeNameConfirmationStatus(payload[0])
self.node_id = payload[1]
|
[
"def",
"from_payload",
"(",
"self",
",",
"payload",
")",
":",
"self",
".",
"status",
"=",
"SetNodeNameConfirmationStatus",
"(",
"payload",
"[",
"0",
"]",
")",
"self",
".",
"node_id",
"=",
"payload",
"[",
"1",
"]"
] |
Init frame from binary data.
|
[
"Init",
"frame",
"from",
"binary",
"data",
"."
] |
train
|
https://github.com/Julius2342/pyvlx/blob/ee78e1324bcb1be5b8d1a9d05ab5496b72eae848/pyvlx/frames/frame_set_node_name.py#L60-L63
|
Julius2342/pyvlx
|
pyvlx/node_helper.py
|
convert_frame_to_node
|
def convert_frame_to_node(pyvlx, frame):
"""Convert FrameGet[All]Node[s]InformationNotification into Node object."""
# pylint: disable=too-many-return-statements
if frame.node_type == NodeTypeWithSubtype.WINDOW_OPENER:
return Window(pyvlx=pyvlx, node_id=frame.node_id, name=frame.name, rain_sensor=False)
if frame.node_type == NodeTypeWithSubtype.WINDOW_OPENER_WITH_RAIN_SENSOR:
return Window(pyvlx=pyvlx, node_id=frame.node_id, name=frame.name, rain_sensor=True)
if frame.node_type == NodeTypeWithSubtype.ROLLER_SHUTTER or \
frame.node_type == NodeTypeWithSubtype.DUAL_ROLLER_SHUTTER:
return RollerShutter(pyvlx=pyvlx, node_id=frame.node_id, name=frame.name)
if frame.node_type == NodeTypeWithSubtype.INTERIOR_VENETIAN_BLIND or \
frame.node_type == NodeTypeWithSubtype.VERTICAL_INTERIOR_BLINDS or \
frame.node_type == NodeTypeWithSubtype.EXTERIOR_VENETIAN_BLIND or \
frame.node_type == NodeTypeWithSubtype.LOUVER_BLIND:
return Blind(pyvlx=pyvlx, node_id=frame.node_id, name=frame.name)
if frame.node_type == NodeTypeWithSubtype.VERTICAL_EXTERIOR_AWNING or \
frame.node_type == NodeTypeWithSubtype.HORIZONTAL_AWNING:
return Awning(pyvlx=pyvlx, node_id=frame.node_id, name=frame.name)
if frame.node_type == NodeTypeWithSubtype.ON_OFF_SWITCH:
return OnOffSwitch(pyvlx=pyvlx, node_id=frame.node_id, name=frame.name)
PYVLXLOG.warning("%s not implemented", frame.node_type)
return None
|
python
|
def convert_frame_to_node(pyvlx, frame):
"""Convert FrameGet[All]Node[s]InformationNotification into Node object."""
# pylint: disable=too-many-return-statements
if frame.node_type == NodeTypeWithSubtype.WINDOW_OPENER:
return Window(pyvlx=pyvlx, node_id=frame.node_id, name=frame.name, rain_sensor=False)
if frame.node_type == NodeTypeWithSubtype.WINDOW_OPENER_WITH_RAIN_SENSOR:
return Window(pyvlx=pyvlx, node_id=frame.node_id, name=frame.name, rain_sensor=True)
if frame.node_type == NodeTypeWithSubtype.ROLLER_SHUTTER or \
frame.node_type == NodeTypeWithSubtype.DUAL_ROLLER_SHUTTER:
return RollerShutter(pyvlx=pyvlx, node_id=frame.node_id, name=frame.name)
if frame.node_type == NodeTypeWithSubtype.INTERIOR_VENETIAN_BLIND or \
frame.node_type == NodeTypeWithSubtype.VERTICAL_INTERIOR_BLINDS or \
frame.node_type == NodeTypeWithSubtype.EXTERIOR_VENETIAN_BLIND or \
frame.node_type == NodeTypeWithSubtype.LOUVER_BLIND:
return Blind(pyvlx=pyvlx, node_id=frame.node_id, name=frame.name)
if frame.node_type == NodeTypeWithSubtype.VERTICAL_EXTERIOR_AWNING or \
frame.node_type == NodeTypeWithSubtype.HORIZONTAL_AWNING:
return Awning(pyvlx=pyvlx, node_id=frame.node_id, name=frame.name)
if frame.node_type == NodeTypeWithSubtype.ON_OFF_SWITCH:
return OnOffSwitch(pyvlx=pyvlx, node_id=frame.node_id, name=frame.name)
PYVLXLOG.warning("%s not implemented", frame.node_type)
return None
|
[
"def",
"convert_frame_to_node",
"(",
"pyvlx",
",",
"frame",
")",
":",
"# pylint: disable=too-many-return-statements",
"if",
"frame",
".",
"node_type",
"==",
"NodeTypeWithSubtype",
".",
"WINDOW_OPENER",
":",
"return",
"Window",
"(",
"pyvlx",
"=",
"pyvlx",
",",
"node_id",
"=",
"frame",
".",
"node_id",
",",
"name",
"=",
"frame",
".",
"name",
",",
"rain_sensor",
"=",
"False",
")",
"if",
"frame",
".",
"node_type",
"==",
"NodeTypeWithSubtype",
".",
"WINDOW_OPENER_WITH_RAIN_SENSOR",
":",
"return",
"Window",
"(",
"pyvlx",
"=",
"pyvlx",
",",
"node_id",
"=",
"frame",
".",
"node_id",
",",
"name",
"=",
"frame",
".",
"name",
",",
"rain_sensor",
"=",
"True",
")",
"if",
"frame",
".",
"node_type",
"==",
"NodeTypeWithSubtype",
".",
"ROLLER_SHUTTER",
"or",
"frame",
".",
"node_type",
"==",
"NodeTypeWithSubtype",
".",
"DUAL_ROLLER_SHUTTER",
":",
"return",
"RollerShutter",
"(",
"pyvlx",
"=",
"pyvlx",
",",
"node_id",
"=",
"frame",
".",
"node_id",
",",
"name",
"=",
"frame",
".",
"name",
")",
"if",
"frame",
".",
"node_type",
"==",
"NodeTypeWithSubtype",
".",
"INTERIOR_VENETIAN_BLIND",
"or",
"frame",
".",
"node_type",
"==",
"NodeTypeWithSubtype",
".",
"VERTICAL_INTERIOR_BLINDS",
"or",
"frame",
".",
"node_type",
"==",
"NodeTypeWithSubtype",
".",
"EXTERIOR_VENETIAN_BLIND",
"or",
"frame",
".",
"node_type",
"==",
"NodeTypeWithSubtype",
".",
"LOUVER_BLIND",
":",
"return",
"Blind",
"(",
"pyvlx",
"=",
"pyvlx",
",",
"node_id",
"=",
"frame",
".",
"node_id",
",",
"name",
"=",
"frame",
".",
"name",
")",
"if",
"frame",
".",
"node_type",
"==",
"NodeTypeWithSubtype",
".",
"VERTICAL_EXTERIOR_AWNING",
"or",
"frame",
".",
"node_type",
"==",
"NodeTypeWithSubtype",
".",
"HORIZONTAL_AWNING",
":",
"return",
"Awning",
"(",
"pyvlx",
"=",
"pyvlx",
",",
"node_id",
"=",
"frame",
".",
"node_id",
",",
"name",
"=",
"frame",
".",
"name",
")",
"if",
"frame",
".",
"node_type",
"==",
"NodeTypeWithSubtype",
".",
"ON_OFF_SWITCH",
":",
"return",
"OnOffSwitch",
"(",
"pyvlx",
"=",
"pyvlx",
",",
"node_id",
"=",
"frame",
".",
"node_id",
",",
"name",
"=",
"frame",
".",
"name",
")",
"PYVLXLOG",
".",
"warning",
"(",
"\"%s not implemented\"",
",",
"frame",
".",
"node_type",
")",
"return",
"None"
] |
Convert FrameGet[All]Node[s]InformationNotification into Node object.
|
[
"Convert",
"FrameGet",
"[",
"All",
"]",
"Node",
"[",
"s",
"]",
"InformationNotification",
"into",
"Node",
"object",
"."
] |
train
|
https://github.com/Julius2342/pyvlx/blob/ee78e1324bcb1be5b8d1a9d05ab5496b72eae848/pyvlx/node_helper.py#L8-L30
|
spacetelescope/synphot_refactor
|
synphot/thermal.py
|
ThermalSpectralElement.temperature
|
def temperature(self, what):
"""Set temperature."""
self._temperature = units.validate_quantity(what, u.K)
|
python
|
def temperature(self, what):
"""Set temperature."""
self._temperature = units.validate_quantity(what, u.K)
|
[
"def",
"temperature",
"(",
"self",
",",
"what",
")",
":",
"self",
".",
"_temperature",
"=",
"units",
".",
"validate_quantity",
"(",
"what",
",",
"u",
".",
"K",
")"
] |
Set temperature.
|
[
"Set",
"temperature",
"."
] |
train
|
https://github.com/spacetelescope/synphot_refactor/blob/9c064f3cff0c41dd8acadc0f67c6350931275b9f/synphot/thermal.py#L53-L55
|
spacetelescope/synphot_refactor
|
synphot/thermal.py
|
ThermalSpectralElement.thermal_source
|
def thermal_source(self):
"""Apply emissivity to an existing beam to produce a thermal
source spectrum (without optical counterpart).
Thermal source spectrum is calculated as follow:
#. Create a blackbody spectrum in PHOTLAM per square arcsec
with `temperature`.
#. Multiply the blackbody with `beam_fill_factor` and ``self``.
Returns
-------
sp : `~synphot.spectrum.SourceSpectrum`
Thermal source spectrum.
"""
sp = (SourceSpectrum(BlackBody1D, temperature=self.temperature) *
units.SR_PER_ARCSEC2 * self.beam_fill_factor * self)
sp.meta['temperature'] = self.temperature
sp.meta['beam_fill_factor'] = self.beam_fill_factor
return sp
|
python
|
def thermal_source(self):
"""Apply emissivity to an existing beam to produce a thermal
source spectrum (without optical counterpart).
Thermal source spectrum is calculated as follow:
#. Create a blackbody spectrum in PHOTLAM per square arcsec
with `temperature`.
#. Multiply the blackbody with `beam_fill_factor` and ``self``.
Returns
-------
sp : `~synphot.spectrum.SourceSpectrum`
Thermal source spectrum.
"""
sp = (SourceSpectrum(BlackBody1D, temperature=self.temperature) *
units.SR_PER_ARCSEC2 * self.beam_fill_factor * self)
sp.meta['temperature'] = self.temperature
sp.meta['beam_fill_factor'] = self.beam_fill_factor
return sp
|
[
"def",
"thermal_source",
"(",
"self",
")",
":",
"sp",
"=",
"(",
"SourceSpectrum",
"(",
"BlackBody1D",
",",
"temperature",
"=",
"self",
".",
"temperature",
")",
"*",
"units",
".",
"SR_PER_ARCSEC2",
"*",
"self",
".",
"beam_fill_factor",
"*",
"self",
")",
"sp",
".",
"meta",
"[",
"'temperature'",
"]",
"=",
"self",
".",
"temperature",
"sp",
".",
"meta",
"[",
"'beam_fill_factor'",
"]",
"=",
"self",
".",
"beam_fill_factor",
"return",
"sp"
] |
Apply emissivity to an existing beam to produce a thermal
source spectrum (without optical counterpart).
Thermal source spectrum is calculated as follow:
#. Create a blackbody spectrum in PHOTLAM per square arcsec
with `temperature`.
#. Multiply the blackbody with `beam_fill_factor` and ``self``.
Returns
-------
sp : `~synphot.spectrum.SourceSpectrum`
Thermal source spectrum.
|
[
"Apply",
"emissivity",
"to",
"an",
"existing",
"beam",
"to",
"produce",
"a",
"thermal",
"source",
"spectrum",
"(",
"without",
"optical",
"counterpart",
")",
"."
] |
train
|
https://github.com/spacetelescope/synphot_refactor/blob/9c064f3cff0c41dd8acadc0f67c6350931275b9f/synphot/thermal.py#L72-L92
|
spacetelescope/synphot_refactor
|
synphot/thermal.py
|
ThermalSpectralElement.from_file
|
def from_file(cls, filename, temperature_key='DEFT',
beamfill_key='BEAMFILL', **kwargs):
"""Creates a thermal spectral element from file.
.. note::
Only FITS format is supported.
Parameters
----------
filename : str
Thermal spectral element filename.
temperature_key, beamfill_key : str
Keywords in FITS *table extension* that store temperature
(in Kelvin) and beam filling factor values.
Beam filling factor is set to 1 if its keyword is missing.
kwargs : dict
Keywords acceptable by :func:`~synphot.specio.read_fits_spec`.
Returns
-------
th : `ThermalSpectralElement`
Empirical thermal spectral element.
Raises
------
synphot.exceptions.SynphotError
Invalid inputs.
"""
if not (filename.endswith('fits') or filename.endswith('fit')):
raise exceptions.SynphotError('Only FITS format is supported.')
# Extra info from table header
ext = kwargs.get('ext', 1)
tab_hdr = fits.getheader(filename, ext=ext)
temperature = tab_hdr.get(temperature_key)
if temperature is None:
raise exceptions.SynphotError(
'Missing {0} keyword.'.format(temperature_key))
beam_fill_factor = tab_hdr.get('BEAMFILL', 1)
if 'flux_unit' not in kwargs:
kwargs['flux_unit'] = cls._internal_flux_unit
if 'flux_col' not in kwargs:
kwargs['flux_col'] = 'EMISSIVITY'
header, wavelengths, em = specio.read_spec(filename, **kwargs)
return cls(
Empirical1D, temperature, beam_fill_factor=beam_fill_factor,
points=wavelengths, lookup_table=em, meta={'header': header})
|
python
|
def from_file(cls, filename, temperature_key='DEFT',
beamfill_key='BEAMFILL', **kwargs):
"""Creates a thermal spectral element from file.
.. note::
Only FITS format is supported.
Parameters
----------
filename : str
Thermal spectral element filename.
temperature_key, beamfill_key : str
Keywords in FITS *table extension* that store temperature
(in Kelvin) and beam filling factor values.
Beam filling factor is set to 1 if its keyword is missing.
kwargs : dict
Keywords acceptable by :func:`~synphot.specio.read_fits_spec`.
Returns
-------
th : `ThermalSpectralElement`
Empirical thermal spectral element.
Raises
------
synphot.exceptions.SynphotError
Invalid inputs.
"""
if not (filename.endswith('fits') or filename.endswith('fit')):
raise exceptions.SynphotError('Only FITS format is supported.')
# Extra info from table header
ext = kwargs.get('ext', 1)
tab_hdr = fits.getheader(filename, ext=ext)
temperature = tab_hdr.get(temperature_key)
if temperature is None:
raise exceptions.SynphotError(
'Missing {0} keyword.'.format(temperature_key))
beam_fill_factor = tab_hdr.get('BEAMFILL', 1)
if 'flux_unit' not in kwargs:
kwargs['flux_unit'] = cls._internal_flux_unit
if 'flux_col' not in kwargs:
kwargs['flux_col'] = 'EMISSIVITY'
header, wavelengths, em = specio.read_spec(filename, **kwargs)
return cls(
Empirical1D, temperature, beam_fill_factor=beam_fill_factor,
points=wavelengths, lookup_table=em, meta={'header': header})
|
[
"def",
"from_file",
"(",
"cls",
",",
"filename",
",",
"temperature_key",
"=",
"'DEFT'",
",",
"beamfill_key",
"=",
"'BEAMFILL'",
",",
"*",
"*",
"kwargs",
")",
":",
"if",
"not",
"(",
"filename",
".",
"endswith",
"(",
"'fits'",
")",
"or",
"filename",
".",
"endswith",
"(",
"'fit'",
")",
")",
":",
"raise",
"exceptions",
".",
"SynphotError",
"(",
"'Only FITS format is supported.'",
")",
"# Extra info from table header",
"ext",
"=",
"kwargs",
".",
"get",
"(",
"'ext'",
",",
"1",
")",
"tab_hdr",
"=",
"fits",
".",
"getheader",
"(",
"filename",
",",
"ext",
"=",
"ext",
")",
"temperature",
"=",
"tab_hdr",
".",
"get",
"(",
"temperature_key",
")",
"if",
"temperature",
"is",
"None",
":",
"raise",
"exceptions",
".",
"SynphotError",
"(",
"'Missing {0} keyword.'",
".",
"format",
"(",
"temperature_key",
")",
")",
"beam_fill_factor",
"=",
"tab_hdr",
".",
"get",
"(",
"'BEAMFILL'",
",",
"1",
")",
"if",
"'flux_unit'",
"not",
"in",
"kwargs",
":",
"kwargs",
"[",
"'flux_unit'",
"]",
"=",
"cls",
".",
"_internal_flux_unit",
"if",
"'flux_col'",
"not",
"in",
"kwargs",
":",
"kwargs",
"[",
"'flux_col'",
"]",
"=",
"'EMISSIVITY'",
"header",
",",
"wavelengths",
",",
"em",
"=",
"specio",
".",
"read_spec",
"(",
"filename",
",",
"*",
"*",
"kwargs",
")",
"return",
"cls",
"(",
"Empirical1D",
",",
"temperature",
",",
"beam_fill_factor",
"=",
"beam_fill_factor",
",",
"points",
"=",
"wavelengths",
",",
"lookup_table",
"=",
"em",
",",
"meta",
"=",
"{",
"'header'",
":",
"header",
"}",
")"
] |
Creates a thermal spectral element from file.
.. note::
Only FITS format is supported.
Parameters
----------
filename : str
Thermal spectral element filename.
temperature_key, beamfill_key : str
Keywords in FITS *table extension* that store temperature
(in Kelvin) and beam filling factor values.
Beam filling factor is set to 1 if its keyword is missing.
kwargs : dict
Keywords acceptable by :func:`~synphot.specio.read_fits_spec`.
Returns
-------
th : `ThermalSpectralElement`
Empirical thermal spectral element.
Raises
------
synphot.exceptions.SynphotError
Invalid inputs.
|
[
"Creates",
"a",
"thermal",
"spectral",
"element",
"from",
"file",
"."
] |
train
|
https://github.com/spacetelescope/synphot_refactor/blob/9c064f3cff0c41dd8acadc0f67c6350931275b9f/synphot/thermal.py#L95-L150
|
Julius2342/pyvlx
|
pyvlx/frames/frame_get_all_nodes_information.py
|
FrameGetAllNodesInformationConfirmation.from_payload
|
def from_payload(self, payload):
"""Init frame from binary data."""
self.status = AllNodesInformationStatus(payload[0])
self.number_of_nodes = payload[1]
|
python
|
def from_payload(self, payload):
"""Init frame from binary data."""
self.status = AllNodesInformationStatus(payload[0])
self.number_of_nodes = payload[1]
|
[
"def",
"from_payload",
"(",
"self",
",",
"payload",
")",
":",
"self",
".",
"status",
"=",
"AllNodesInformationStatus",
"(",
"payload",
"[",
"0",
"]",
")",
"self",
".",
"number_of_nodes",
"=",
"payload",
"[",
"1",
"]"
] |
Init frame from binary data.
|
[
"Init",
"frame",
"from",
"binary",
"data",
"."
] |
train
|
https://github.com/Julius2342/pyvlx/blob/ee78e1324bcb1be5b8d1a9d05ab5496b72eae848/pyvlx/frames/frame_get_all_nodes_information.py#L46-L49
|
Julius2342/pyvlx
|
pyvlx/frames/frame_get_all_nodes_information.py
|
FrameGetAllNodesInformationNotification.get_payload
|
def get_payload(self):
"""Return Payload."""
payload = bytes()
payload += bytes([self.node_id])
payload += bytes([self.order >> 8 & 255, self.order & 255])
payload += bytes([self.placement])
payload += bytes(string_to_bytes(self.name, 64))
payload += bytes([self.velocity.value])
payload += bytes([self.node_type.value >> 8 & 255, self.node_type.value & 255])
payload += bytes([self.product_group])
payload += bytes([self.product_type])
payload += bytes([self.node_variation.value])
payload += bytes([self.power_mode])
payload += bytes([self.build_number])
payload += bytes(self._serial_number)
payload += bytes([self.state])
payload += bytes(self.current_position.raw)
payload += bytes(self.target.raw)
payload += bytes(self.current_position_fp1.raw)
payload += bytes(self.current_position_fp2.raw)
payload += bytes(self.current_position_fp3.raw)
payload += bytes(self.current_position_fp4.raw)
payload += bytes([self.remaining_time >> 8 & 255, self.remaining_time & 255])
payload += struct.pack(">I", self.timestamp)
payload += bytes(self.alias_array)
return payload
|
python
|
def get_payload(self):
"""Return Payload."""
payload = bytes()
payload += bytes([self.node_id])
payload += bytes([self.order >> 8 & 255, self.order & 255])
payload += bytes([self.placement])
payload += bytes(string_to_bytes(self.name, 64))
payload += bytes([self.velocity.value])
payload += bytes([self.node_type.value >> 8 & 255, self.node_type.value & 255])
payload += bytes([self.product_group])
payload += bytes([self.product_type])
payload += bytes([self.node_variation.value])
payload += bytes([self.power_mode])
payload += bytes([self.build_number])
payload += bytes(self._serial_number)
payload += bytes([self.state])
payload += bytes(self.current_position.raw)
payload += bytes(self.target.raw)
payload += bytes(self.current_position_fp1.raw)
payload += bytes(self.current_position_fp2.raw)
payload += bytes(self.current_position_fp3.raw)
payload += bytes(self.current_position_fp4.raw)
payload += bytes([self.remaining_time >> 8 & 255, self.remaining_time & 255])
payload += struct.pack(">I", self.timestamp)
payload += bytes(self.alias_array)
return payload
|
[
"def",
"get_payload",
"(",
"self",
")",
":",
"payload",
"=",
"bytes",
"(",
")",
"payload",
"+=",
"bytes",
"(",
"[",
"self",
".",
"node_id",
"]",
")",
"payload",
"+=",
"bytes",
"(",
"[",
"self",
".",
"order",
">>",
"8",
"&",
"255",
",",
"self",
".",
"order",
"&",
"255",
"]",
")",
"payload",
"+=",
"bytes",
"(",
"[",
"self",
".",
"placement",
"]",
")",
"payload",
"+=",
"bytes",
"(",
"string_to_bytes",
"(",
"self",
".",
"name",
",",
"64",
")",
")",
"payload",
"+=",
"bytes",
"(",
"[",
"self",
".",
"velocity",
".",
"value",
"]",
")",
"payload",
"+=",
"bytes",
"(",
"[",
"self",
".",
"node_type",
".",
"value",
">>",
"8",
"&",
"255",
",",
"self",
".",
"node_type",
".",
"value",
"&",
"255",
"]",
")",
"payload",
"+=",
"bytes",
"(",
"[",
"self",
".",
"product_group",
"]",
")",
"payload",
"+=",
"bytes",
"(",
"[",
"self",
".",
"product_type",
"]",
")",
"payload",
"+=",
"bytes",
"(",
"[",
"self",
".",
"node_variation",
".",
"value",
"]",
")",
"payload",
"+=",
"bytes",
"(",
"[",
"self",
".",
"power_mode",
"]",
")",
"payload",
"+=",
"bytes",
"(",
"[",
"self",
".",
"build_number",
"]",
")",
"payload",
"+=",
"bytes",
"(",
"self",
".",
"_serial_number",
")",
"payload",
"+=",
"bytes",
"(",
"[",
"self",
".",
"state",
"]",
")",
"payload",
"+=",
"bytes",
"(",
"self",
".",
"current_position",
".",
"raw",
")",
"payload",
"+=",
"bytes",
"(",
"self",
".",
"target",
".",
"raw",
")",
"payload",
"+=",
"bytes",
"(",
"self",
".",
"current_position_fp1",
".",
"raw",
")",
"payload",
"+=",
"bytes",
"(",
"self",
".",
"current_position_fp2",
".",
"raw",
")",
"payload",
"+=",
"bytes",
"(",
"self",
".",
"current_position_fp3",
".",
"raw",
")",
"payload",
"+=",
"bytes",
"(",
"self",
".",
"current_position_fp4",
".",
"raw",
")",
"payload",
"+=",
"bytes",
"(",
"[",
"self",
".",
"remaining_time",
">>",
"8",
"&",
"255",
",",
"self",
".",
"remaining_time",
"&",
"255",
"]",
")",
"payload",
"+=",
"struct",
".",
"pack",
"(",
"\">I\"",
",",
"self",
".",
"timestamp",
")",
"payload",
"+=",
"bytes",
"(",
"self",
".",
"alias_array",
")",
"return",
"payload"
] |
Return Payload.
|
[
"Return",
"Payload",
"."
] |
train
|
https://github.com/Julius2342/pyvlx/blob/ee78e1324bcb1be5b8d1a9d05ab5496b72eae848/pyvlx/frames/frame_get_all_nodes_information.py#L92-L118
|
Julius2342/pyvlx
|
pyvlx/frames/frame_get_all_nodes_information.py
|
FrameGetAllNodesInformationNotification.from_payload
|
def from_payload(self, payload):
"""Init frame from binary data."""
self.node_id = payload[0]
self.order = payload[1] * 256 + payload[2]
self.placement = payload[3]
self.name = bytes_to_string(payload[4:68])
self.velocity = Velocity(payload[68])
self.node_type = NodeTypeWithSubtype(payload[69] * 256 + payload[70])
self.product_group = payload[71]
self.product_type = payload[72]
self.node_variation = NodeVariation(payload[73])
self.power_mode = payload[74]
self.build_number = payload[75]
self._serial_number = payload[76:84]
self.state = payload[84]
self.current_position = Parameter(payload[85:87])
self.target = Parameter(payload[87:89])
self.current_position_fp1 = Parameter(payload[89:91])
self.current_position_fp2 = Parameter(payload[91:93])
self.current_position_fp3 = Parameter(payload[93:95])
self.current_position_fp4 = Parameter(payload[95:97])
self.remaining_time = payload[97] * 256 + payload[98]
self.timestamp = struct.unpack(">I", payload[99:103])[0]
self.alias_array = AliasArray(payload[103:125])
|
python
|
def from_payload(self, payload):
"""Init frame from binary data."""
self.node_id = payload[0]
self.order = payload[1] * 256 + payload[2]
self.placement = payload[3]
self.name = bytes_to_string(payload[4:68])
self.velocity = Velocity(payload[68])
self.node_type = NodeTypeWithSubtype(payload[69] * 256 + payload[70])
self.product_group = payload[71]
self.product_type = payload[72]
self.node_variation = NodeVariation(payload[73])
self.power_mode = payload[74]
self.build_number = payload[75]
self._serial_number = payload[76:84]
self.state = payload[84]
self.current_position = Parameter(payload[85:87])
self.target = Parameter(payload[87:89])
self.current_position_fp1 = Parameter(payload[89:91])
self.current_position_fp2 = Parameter(payload[91:93])
self.current_position_fp3 = Parameter(payload[93:95])
self.current_position_fp4 = Parameter(payload[95:97])
self.remaining_time = payload[97] * 256 + payload[98]
self.timestamp = struct.unpack(">I", payload[99:103])[0]
self.alias_array = AliasArray(payload[103:125])
|
[
"def",
"from_payload",
"(",
"self",
",",
"payload",
")",
":",
"self",
".",
"node_id",
"=",
"payload",
"[",
"0",
"]",
"self",
".",
"order",
"=",
"payload",
"[",
"1",
"]",
"*",
"256",
"+",
"payload",
"[",
"2",
"]",
"self",
".",
"placement",
"=",
"payload",
"[",
"3",
"]",
"self",
".",
"name",
"=",
"bytes_to_string",
"(",
"payload",
"[",
"4",
":",
"68",
"]",
")",
"self",
".",
"velocity",
"=",
"Velocity",
"(",
"payload",
"[",
"68",
"]",
")",
"self",
".",
"node_type",
"=",
"NodeTypeWithSubtype",
"(",
"payload",
"[",
"69",
"]",
"*",
"256",
"+",
"payload",
"[",
"70",
"]",
")",
"self",
".",
"product_group",
"=",
"payload",
"[",
"71",
"]",
"self",
".",
"product_type",
"=",
"payload",
"[",
"72",
"]",
"self",
".",
"node_variation",
"=",
"NodeVariation",
"(",
"payload",
"[",
"73",
"]",
")",
"self",
".",
"power_mode",
"=",
"payload",
"[",
"74",
"]",
"self",
".",
"build_number",
"=",
"payload",
"[",
"75",
"]",
"self",
".",
"_serial_number",
"=",
"payload",
"[",
"76",
":",
"84",
"]",
"self",
".",
"state",
"=",
"payload",
"[",
"84",
"]",
"self",
".",
"current_position",
"=",
"Parameter",
"(",
"payload",
"[",
"85",
":",
"87",
"]",
")",
"self",
".",
"target",
"=",
"Parameter",
"(",
"payload",
"[",
"87",
":",
"89",
"]",
")",
"self",
".",
"current_position_fp1",
"=",
"Parameter",
"(",
"payload",
"[",
"89",
":",
"91",
"]",
")",
"self",
".",
"current_position_fp2",
"=",
"Parameter",
"(",
"payload",
"[",
"91",
":",
"93",
"]",
")",
"self",
".",
"current_position_fp3",
"=",
"Parameter",
"(",
"payload",
"[",
"93",
":",
"95",
"]",
")",
"self",
".",
"current_position_fp4",
"=",
"Parameter",
"(",
"payload",
"[",
"95",
":",
"97",
"]",
")",
"self",
".",
"remaining_time",
"=",
"payload",
"[",
"97",
"]",
"*",
"256",
"+",
"payload",
"[",
"98",
"]",
"self",
".",
"timestamp",
"=",
"struct",
".",
"unpack",
"(",
"\">I\"",
",",
"payload",
"[",
"99",
":",
"103",
"]",
")",
"[",
"0",
"]",
"self",
".",
"alias_array",
"=",
"AliasArray",
"(",
"payload",
"[",
"103",
":",
"125",
"]",
")"
] |
Init frame from binary data.
|
[
"Init",
"frame",
"from",
"binary",
"data",
"."
] |
train
|
https://github.com/Julius2342/pyvlx/blob/ee78e1324bcb1be5b8d1a9d05ab5496b72eae848/pyvlx/frames/frame_get_all_nodes_information.py#L120-L143
|
Julius2342/pyvlx
|
pyvlx/parameter.py
|
Parameter.from_parameter
|
def from_parameter(self, parameter):
"""Set internal raw state from parameter."""
if not isinstance(parameter, Parameter):
raise Exception("parameter::from_parameter_wrong_object")
self.raw = parameter.raw
|
python
|
def from_parameter(self, parameter):
"""Set internal raw state from parameter."""
if not isinstance(parameter, Parameter):
raise Exception("parameter::from_parameter_wrong_object")
self.raw = parameter.raw
|
[
"def",
"from_parameter",
"(",
"self",
",",
"parameter",
")",
":",
"if",
"not",
"isinstance",
"(",
"parameter",
",",
"Parameter",
")",
":",
"raise",
"Exception",
"(",
"\"parameter::from_parameter_wrong_object\"",
")",
"self",
".",
"raw",
"=",
"parameter",
".",
"raw"
] |
Set internal raw state from parameter.
|
[
"Set",
"internal",
"raw",
"state",
"from",
"parameter",
"."
] |
train
|
https://github.com/Julius2342/pyvlx/blob/ee78e1324bcb1be5b8d1a9d05ab5496b72eae848/pyvlx/parameter.py#L21-L25
|
Julius2342/pyvlx
|
pyvlx/parameter.py
|
Parameter.from_int
|
def from_int(value):
"""Create raw out of position vlaue."""
if not isinstance(value, int):
raise PyVLXException("value_has_to_be_int")
if not Parameter.is_valid_int(value):
raise PyVLXException("value_out_of_range")
return bytes([value >> 8 & 255, value & 255])
|
python
|
def from_int(value):
"""Create raw out of position vlaue."""
if not isinstance(value, int):
raise PyVLXException("value_has_to_be_int")
if not Parameter.is_valid_int(value):
raise PyVLXException("value_out_of_range")
return bytes([value >> 8 & 255, value & 255])
|
[
"def",
"from_int",
"(",
"value",
")",
":",
"if",
"not",
"isinstance",
"(",
"value",
",",
"int",
")",
":",
"raise",
"PyVLXException",
"(",
"\"value_has_to_be_int\"",
")",
"if",
"not",
"Parameter",
".",
"is_valid_int",
"(",
"value",
")",
":",
"raise",
"PyVLXException",
"(",
"\"value_out_of_range\"",
")",
"return",
"bytes",
"(",
"[",
"value",
">>",
"8",
"&",
"255",
",",
"value",
"&",
"255",
"]",
")"
] |
Create raw out of position vlaue.
|
[
"Create",
"raw",
"out",
"of",
"position",
"vlaue",
"."
] |
train
|
https://github.com/Julius2342/pyvlx/blob/ee78e1324bcb1be5b8d1a9d05ab5496b72eae848/pyvlx/parameter.py#L28-L34
|
Julius2342/pyvlx
|
pyvlx/parameter.py
|
Parameter.is_valid_int
|
def is_valid_int(value):
"""Test if value can be rendered out of int."""
if 0 <= value <= Parameter.MAX: # This includes ON and OFF
return True
if value == Parameter.UNKNOWN_VALUE:
return True
if value == Parameter.CURRENT_POSITION:
return True
return False
|
python
|
def is_valid_int(value):
"""Test if value can be rendered out of int."""
if 0 <= value <= Parameter.MAX: # This includes ON and OFF
return True
if value == Parameter.UNKNOWN_VALUE:
return True
if value == Parameter.CURRENT_POSITION:
return True
return False
|
[
"def",
"is_valid_int",
"(",
"value",
")",
":",
"if",
"0",
"<=",
"value",
"<=",
"Parameter",
".",
"MAX",
":",
"# This includes ON and OFF",
"return",
"True",
"if",
"value",
"==",
"Parameter",
".",
"UNKNOWN_VALUE",
":",
"return",
"True",
"if",
"value",
"==",
"Parameter",
".",
"CURRENT_POSITION",
":",
"return",
"True",
"return",
"False"
] |
Test if value can be rendered out of int.
|
[
"Test",
"if",
"value",
"can",
"be",
"rendered",
"out",
"of",
"int",
"."
] |
train
|
https://github.com/Julius2342/pyvlx/blob/ee78e1324bcb1be5b8d1a9d05ab5496b72eae848/pyvlx/parameter.py#L37-L45
|
Julius2342/pyvlx
|
pyvlx/parameter.py
|
Parameter.from_raw
|
def from_raw(raw):
"""Test if raw packets are valid for initialization of Position."""
if not isinstance(raw, bytes):
raise PyVLXException("Position::raw_must_be_bytes")
if len(raw) != 2:
raise PyVLXException("Position::raw_must_be_two_bytes")
if raw != Position.from_int(Position.CURRENT_POSITION) and \
raw != Position.from_int(Position.UNKNOWN_VALUE) and \
Position.to_int(raw) > Position.MAX:
raise PyVLXException("position::raw_exceed_limit", raw=raw)
return raw
|
python
|
def from_raw(raw):
"""Test if raw packets are valid for initialization of Position."""
if not isinstance(raw, bytes):
raise PyVLXException("Position::raw_must_be_bytes")
if len(raw) != 2:
raise PyVLXException("Position::raw_must_be_two_bytes")
if raw != Position.from_int(Position.CURRENT_POSITION) and \
raw != Position.from_int(Position.UNKNOWN_VALUE) and \
Position.to_int(raw) > Position.MAX:
raise PyVLXException("position::raw_exceed_limit", raw=raw)
return raw
|
[
"def",
"from_raw",
"(",
"raw",
")",
":",
"if",
"not",
"isinstance",
"(",
"raw",
",",
"bytes",
")",
":",
"raise",
"PyVLXException",
"(",
"\"Position::raw_must_be_bytes\"",
")",
"if",
"len",
"(",
"raw",
")",
"!=",
"2",
":",
"raise",
"PyVLXException",
"(",
"\"Position::raw_must_be_two_bytes\"",
")",
"if",
"raw",
"!=",
"Position",
".",
"from_int",
"(",
"Position",
".",
"CURRENT_POSITION",
")",
"and",
"raw",
"!=",
"Position",
".",
"from_int",
"(",
"Position",
".",
"UNKNOWN_VALUE",
")",
"and",
"Position",
".",
"to_int",
"(",
"raw",
")",
">",
"Position",
".",
"MAX",
":",
"raise",
"PyVLXException",
"(",
"\"position::raw_exceed_limit\"",
",",
"raw",
"=",
"raw",
")",
"return",
"raw"
] |
Test if raw packets are valid for initialization of Position.
|
[
"Test",
"if",
"raw",
"packets",
"are",
"valid",
"for",
"initialization",
"of",
"Position",
"."
] |
train
|
https://github.com/Julius2342/pyvlx/blob/ee78e1324bcb1be5b8d1a9d05ab5496b72eae848/pyvlx/parameter.py#L48-L58
|
Julius2342/pyvlx
|
pyvlx/parameter.py
|
Position.from_percent
|
def from_percent(position_percent):
"""Create raw value out of percent position."""
if not isinstance(position_percent, int):
raise PyVLXException("Position::position_percent_has_to_be_int")
if position_percent < 0:
raise PyVLXException("Position::position_percent_has_to_be_positive")
if position_percent > 100:
raise PyVLXException("Position::position_percent_out_of_range")
return bytes([position_percent*2, 0])
|
python
|
def from_percent(position_percent):
"""Create raw value out of percent position."""
if not isinstance(position_percent, int):
raise PyVLXException("Position::position_percent_has_to_be_int")
if position_percent < 0:
raise PyVLXException("Position::position_percent_has_to_be_positive")
if position_percent > 100:
raise PyVLXException("Position::position_percent_out_of_range")
return bytes([position_percent*2, 0])
|
[
"def",
"from_percent",
"(",
"position_percent",
")",
":",
"if",
"not",
"isinstance",
"(",
"position_percent",
",",
"int",
")",
":",
"raise",
"PyVLXException",
"(",
"\"Position::position_percent_has_to_be_int\"",
")",
"if",
"position_percent",
"<",
"0",
":",
"raise",
"PyVLXException",
"(",
"\"Position::position_percent_has_to_be_positive\"",
")",
"if",
"position_percent",
">",
"100",
":",
"raise",
"PyVLXException",
"(",
"\"Position::position_percent_out_of_range\"",
")",
"return",
"bytes",
"(",
"[",
"position_percent",
"*",
"2",
",",
"0",
"]",
")"
] |
Create raw value out of percent position.
|
[
"Create",
"raw",
"value",
"out",
"of",
"percent",
"position",
"."
] |
train
|
https://github.com/Julius2342/pyvlx/blob/ee78e1324bcb1be5b8d1a9d05ab5496b72eae848/pyvlx/parameter.py#L172-L180
|
Julius2342/pyvlx
|
pyvlx/frames/frame_get_version.py
|
FrameGetVersionConfirmation.product
|
def product(self):
"""Return product as human readable string."""
if self.product_group == 14 and self.product_type == 3:
return "KLF 200"
return "Unknown Product: {}:{}".format(self.product_group, self.product_type)
|
python
|
def product(self):
"""Return product as human readable string."""
if self.product_group == 14 and self.product_type == 3:
return "KLF 200"
return "Unknown Product: {}:{}".format(self.product_group, self.product_type)
|
[
"def",
"product",
"(",
"self",
")",
":",
"if",
"self",
".",
"product_group",
"==",
"14",
"and",
"self",
".",
"product_type",
"==",
"3",
":",
"return",
"\"KLF 200\"",
"return",
"\"Unknown Product: {}:{}\"",
".",
"format",
"(",
"self",
".",
"product_group",
",",
"self",
".",
"product_type",
")"
] |
Return product as human readable string.
|
[
"Return",
"product",
"as",
"human",
"readable",
"string",
"."
] |
train
|
https://github.com/Julius2342/pyvlx/blob/ee78e1324bcb1be5b8d1a9d05ab5496b72eae848/pyvlx/frames/frame_get_version.py#L44-L48
|
Julius2342/pyvlx
|
pyvlx/frames/frame_get_version.py
|
FrameGetVersionConfirmation.get_payload
|
def get_payload(self):
"""Return Payload."""
ret = self._software_version
ret += bytes([self.hardware_version, self.product_group, self.product_type])
return ret
|
python
|
def get_payload(self):
"""Return Payload."""
ret = self._software_version
ret += bytes([self.hardware_version, self.product_group, self.product_type])
return ret
|
[
"def",
"get_payload",
"(",
"self",
")",
":",
"ret",
"=",
"self",
".",
"_software_version",
"ret",
"+=",
"bytes",
"(",
"[",
"self",
".",
"hardware_version",
",",
"self",
".",
"product_group",
",",
"self",
".",
"product_type",
"]",
")",
"return",
"ret"
] |
Return Payload.
|
[
"Return",
"Payload",
"."
] |
train
|
https://github.com/Julius2342/pyvlx/blob/ee78e1324bcb1be5b8d1a9d05ab5496b72eae848/pyvlx/frames/frame_get_version.py#L50-L54
|
Julius2342/pyvlx
|
pyvlx/frames/frame_get_version.py
|
FrameGetVersionConfirmation.from_payload
|
def from_payload(self, payload):
"""Init frame from binary data."""
self._software_version = payload[0:6]
self.hardware_version = payload[6]
self.product_group = payload[7]
self.product_type = payload[8]
|
python
|
def from_payload(self, payload):
"""Init frame from binary data."""
self._software_version = payload[0:6]
self.hardware_version = payload[6]
self.product_group = payload[7]
self.product_type = payload[8]
|
[
"def",
"from_payload",
"(",
"self",
",",
"payload",
")",
":",
"self",
".",
"_software_version",
"=",
"payload",
"[",
"0",
":",
"6",
"]",
"self",
".",
"hardware_version",
"=",
"payload",
"[",
"6",
"]",
"self",
".",
"product_group",
"=",
"payload",
"[",
"7",
"]",
"self",
".",
"product_type",
"=",
"payload",
"[",
"8",
"]"
] |
Init frame from binary data.
|
[
"Init",
"frame",
"from",
"binary",
"data",
"."
] |
train
|
https://github.com/Julius2342/pyvlx/blob/ee78e1324bcb1be5b8d1a9d05ab5496b72eae848/pyvlx/frames/frame_get_version.py#L56-L61
|
Julius2342/pyvlx
|
pyvlx/frames/frame_activate_scene.py
|
FrameActivateSceneRequest.get_payload
|
def get_payload(self):
"""Return Payload."""
ret = bytes([self.session_id >> 8 & 255, self.session_id & 255])
ret += bytes([self.originator.value])
ret += bytes([self.priority.value])
ret += bytes([self.scene_id])
ret += bytes([self.velocity.value])
return ret
|
python
|
def get_payload(self):
"""Return Payload."""
ret = bytes([self.session_id >> 8 & 255, self.session_id & 255])
ret += bytes([self.originator.value])
ret += bytes([self.priority.value])
ret += bytes([self.scene_id])
ret += bytes([self.velocity.value])
return ret
|
[
"def",
"get_payload",
"(",
"self",
")",
":",
"ret",
"=",
"bytes",
"(",
"[",
"self",
".",
"session_id",
">>",
"8",
"&",
"255",
",",
"self",
".",
"session_id",
"&",
"255",
"]",
")",
"ret",
"+=",
"bytes",
"(",
"[",
"self",
".",
"originator",
".",
"value",
"]",
")",
"ret",
"+=",
"bytes",
"(",
"[",
"self",
".",
"priority",
".",
"value",
"]",
")",
"ret",
"+=",
"bytes",
"(",
"[",
"self",
".",
"scene_id",
"]",
")",
"ret",
"+=",
"bytes",
"(",
"[",
"self",
".",
"velocity",
".",
"value",
"]",
")",
"return",
"ret"
] |
Return Payload.
|
[
"Return",
"Payload",
"."
] |
train
|
https://github.com/Julius2342/pyvlx/blob/ee78e1324bcb1be5b8d1a9d05ab5496b72eae848/pyvlx/frames/frame_activate_scene.py#L23-L30
|
Julius2342/pyvlx
|
pyvlx/frames/frame_activate_scene.py
|
FrameActivateSceneRequest.from_payload
|
def from_payload(self, payload):
"""Init frame from binary data."""
self.session_id = payload[0]*256 + payload[1]
self.originator = Originator(payload[2])
self.priority = Priority(payload[3])
self.scene_id = payload[4]
self.velocity = Velocity(payload[5])
|
python
|
def from_payload(self, payload):
"""Init frame from binary data."""
self.session_id = payload[0]*256 + payload[1]
self.originator = Originator(payload[2])
self.priority = Priority(payload[3])
self.scene_id = payload[4]
self.velocity = Velocity(payload[5])
|
[
"def",
"from_payload",
"(",
"self",
",",
"payload",
")",
":",
"self",
".",
"session_id",
"=",
"payload",
"[",
"0",
"]",
"*",
"256",
"+",
"payload",
"[",
"1",
"]",
"self",
".",
"originator",
"=",
"Originator",
"(",
"payload",
"[",
"2",
"]",
")",
"self",
".",
"priority",
"=",
"Priority",
"(",
"payload",
"[",
"3",
"]",
")",
"self",
".",
"scene_id",
"=",
"payload",
"[",
"4",
"]",
"self",
".",
"velocity",
"=",
"Velocity",
"(",
"payload",
"[",
"5",
"]",
")"
] |
Init frame from binary data.
|
[
"Init",
"frame",
"from",
"binary",
"data",
"."
] |
train
|
https://github.com/Julius2342/pyvlx/blob/ee78e1324bcb1be5b8d1a9d05ab5496b72eae848/pyvlx/frames/frame_activate_scene.py#L32-L38
|
Julius2342/pyvlx
|
pyvlx/frames/frame_activate_scene.py
|
FrameActivateSceneConfirmation.get_payload
|
def get_payload(self):
"""Return Payload."""
ret = bytes([self.status.value])
ret += bytes([self.session_id >> 8 & 255, self.session_id & 255])
return ret
|
python
|
def get_payload(self):
"""Return Payload."""
ret = bytes([self.status.value])
ret += bytes([self.session_id >> 8 & 255, self.session_id & 255])
return ret
|
[
"def",
"get_payload",
"(",
"self",
")",
":",
"ret",
"=",
"bytes",
"(",
"[",
"self",
".",
"status",
".",
"value",
"]",
")",
"ret",
"+=",
"bytes",
"(",
"[",
"self",
".",
"session_id",
">>",
"8",
"&",
"255",
",",
"self",
".",
"session_id",
"&",
"255",
"]",
")",
"return",
"ret"
] |
Return Payload.
|
[
"Return",
"Payload",
"."
] |
train
|
https://github.com/Julius2342/pyvlx/blob/ee78e1324bcb1be5b8d1a9d05ab5496b72eae848/pyvlx/frames/frame_activate_scene.py#L65-L69
|
Julius2342/pyvlx
|
pyvlx/frames/frame_activate_scene.py
|
FrameActivateSceneConfirmation.from_payload
|
def from_payload(self, payload):
"""Init frame from binary data."""
self.status = ActivateSceneConfirmationStatus(payload[0])
self.session_id = payload[1]*256 + payload[2]
|
python
|
def from_payload(self, payload):
"""Init frame from binary data."""
self.status = ActivateSceneConfirmationStatus(payload[0])
self.session_id = payload[1]*256 + payload[2]
|
[
"def",
"from_payload",
"(",
"self",
",",
"payload",
")",
":",
"self",
".",
"status",
"=",
"ActivateSceneConfirmationStatus",
"(",
"payload",
"[",
"0",
"]",
")",
"self",
".",
"session_id",
"=",
"payload",
"[",
"1",
"]",
"*",
"256",
"+",
"payload",
"[",
"2",
"]"
] |
Init frame from binary data.
|
[
"Init",
"frame",
"from",
"binary",
"data",
"."
] |
train
|
https://github.com/Julius2342/pyvlx/blob/ee78e1324bcb1be5b8d1a9d05ab5496b72eae848/pyvlx/frames/frame_activate_scene.py#L71-L74
|
Julius2342/pyvlx
|
pyvlx/frames/frame_command_send.py
|
FrameCommandSendRequest.get_payload
|
def get_payload(self):
"""Return Payload."""
# Session id
ret = bytes([self.session_id >> 8 & 255, self.session_id & 255])
ret += bytes([self.originator.value])
ret += bytes([self.priority.value])
ret += bytes([0]) # ParameterActive pointing to main parameter (MP)
# FPI 1+2
ret += bytes([0])
ret += bytes([0])
# Main parameter + functional parameter
ret += bytes(self.parameter)
ret += bytes(32)
# Nodes array: Number of nodes + node array + padding
ret += bytes([len(self.node_ids)]) # index array count
ret += bytes(self.node_ids) + bytes(20-len(self.node_ids))
# Priority Level Lock
ret += bytes([0])
# Priority Level information 1+2
ret += bytes([0, 0])
# Locktime
ret += bytes([0])
return ret
|
python
|
def get_payload(self):
"""Return Payload."""
# Session id
ret = bytes([self.session_id >> 8 & 255, self.session_id & 255])
ret += bytes([self.originator.value])
ret += bytes([self.priority.value])
ret += bytes([0]) # ParameterActive pointing to main parameter (MP)
# FPI 1+2
ret += bytes([0])
ret += bytes([0])
# Main parameter + functional parameter
ret += bytes(self.parameter)
ret += bytes(32)
# Nodes array: Number of nodes + node array + padding
ret += bytes([len(self.node_ids)]) # index array count
ret += bytes(self.node_ids) + bytes(20-len(self.node_ids))
# Priority Level Lock
ret += bytes([0])
# Priority Level information 1+2
ret += bytes([0, 0])
# Locktime
ret += bytes([0])
return ret
|
[
"def",
"get_payload",
"(",
"self",
")",
":",
"# Session id",
"ret",
"=",
"bytes",
"(",
"[",
"self",
".",
"session_id",
">>",
"8",
"&",
"255",
",",
"self",
".",
"session_id",
"&",
"255",
"]",
")",
"ret",
"+=",
"bytes",
"(",
"[",
"self",
".",
"originator",
".",
"value",
"]",
")",
"ret",
"+=",
"bytes",
"(",
"[",
"self",
".",
"priority",
".",
"value",
"]",
")",
"ret",
"+=",
"bytes",
"(",
"[",
"0",
"]",
")",
"# ParameterActive pointing to main parameter (MP)",
"# FPI 1+2",
"ret",
"+=",
"bytes",
"(",
"[",
"0",
"]",
")",
"ret",
"+=",
"bytes",
"(",
"[",
"0",
"]",
")",
"# Main parameter + functional parameter",
"ret",
"+=",
"bytes",
"(",
"self",
".",
"parameter",
")",
"ret",
"+=",
"bytes",
"(",
"32",
")",
"# Nodes array: Number of nodes + node array + padding",
"ret",
"+=",
"bytes",
"(",
"[",
"len",
"(",
"self",
".",
"node_ids",
")",
"]",
")",
"# index array count",
"ret",
"+=",
"bytes",
"(",
"self",
".",
"node_ids",
")",
"+",
"bytes",
"(",
"20",
"-",
"len",
"(",
"self",
".",
"node_ids",
")",
")",
"# Priority Level Lock",
"ret",
"+=",
"bytes",
"(",
"[",
"0",
"]",
")",
"# Priority Level information 1+2",
"ret",
"+=",
"bytes",
"(",
"[",
"0",
",",
"0",
"]",
")",
"# Locktime",
"ret",
"+=",
"bytes",
"(",
"[",
"0",
"]",
")",
"return",
"ret"
] |
Return Payload.
|
[
"Return",
"Payload",
"."
] |
train
|
https://github.com/Julius2342/pyvlx/blob/ee78e1324bcb1be5b8d1a9d05ab5496b72eae848/pyvlx/frames/frame_command_send.py#L25-L50
|
Julius2342/pyvlx
|
pyvlx/frames/frame_command_send.py
|
FrameCommandSendRequest.from_payload
|
def from_payload(self, payload):
"""Init frame from binary data."""
self.session_id = payload[0]*256 + payload[1]
self.originator = Originator(payload[2])
self.priority = Priority(payload[3])
len_node_ids = payload[41]
if len_node_ids > 20:
raise PyVLXException("command_send_request_wrong_node_length")
self.node_ids = []
for i in range(len_node_ids):
self.node_ids.append(payload[42] + i)
self.parameter = Parameter(payload[7:9])
|
python
|
def from_payload(self, payload):
"""Init frame from binary data."""
self.session_id = payload[0]*256 + payload[1]
self.originator = Originator(payload[2])
self.priority = Priority(payload[3])
len_node_ids = payload[41]
if len_node_ids > 20:
raise PyVLXException("command_send_request_wrong_node_length")
self.node_ids = []
for i in range(len_node_ids):
self.node_ids.append(payload[42] + i)
self.parameter = Parameter(payload[7:9])
|
[
"def",
"from_payload",
"(",
"self",
",",
"payload",
")",
":",
"self",
".",
"session_id",
"=",
"payload",
"[",
"0",
"]",
"*",
"256",
"+",
"payload",
"[",
"1",
"]",
"self",
".",
"originator",
"=",
"Originator",
"(",
"payload",
"[",
"2",
"]",
")",
"self",
".",
"priority",
"=",
"Priority",
"(",
"payload",
"[",
"3",
"]",
")",
"len_node_ids",
"=",
"payload",
"[",
"41",
"]",
"if",
"len_node_ids",
">",
"20",
":",
"raise",
"PyVLXException",
"(",
"\"command_send_request_wrong_node_length\"",
")",
"self",
".",
"node_ids",
"=",
"[",
"]",
"for",
"i",
"in",
"range",
"(",
"len_node_ids",
")",
":",
"self",
".",
"node_ids",
".",
"append",
"(",
"payload",
"[",
"42",
"]",
"+",
"i",
")",
"self",
".",
"parameter",
"=",
"Parameter",
"(",
"payload",
"[",
"7",
":",
"9",
"]",
")"
] |
Init frame from binary data.
|
[
"Init",
"frame",
"from",
"binary",
"data",
"."
] |
train
|
https://github.com/Julius2342/pyvlx/blob/ee78e1324bcb1be5b8d1a9d05ab5496b72eae848/pyvlx/frames/frame_command_send.py#L52-L65
|
Julius2342/pyvlx
|
pyvlx/frames/frame_command_send.py
|
FrameCommandSendConfirmation.from_payload
|
def from_payload(self, payload):
"""Init frame from binary data."""
self.session_id = payload[0]*256 + payload[1]
self.status = CommandSendConfirmationStatus(payload[2])
|
python
|
def from_payload(self, payload):
"""Init frame from binary data."""
self.session_id = payload[0]*256 + payload[1]
self.status = CommandSendConfirmationStatus(payload[2])
|
[
"def",
"from_payload",
"(",
"self",
",",
"payload",
")",
":",
"self",
".",
"session_id",
"=",
"payload",
"[",
"0",
"]",
"*",
"256",
"+",
"payload",
"[",
"1",
"]",
"self",
".",
"status",
"=",
"CommandSendConfirmationStatus",
"(",
"payload",
"[",
"2",
"]",
")"
] |
Init frame from binary data.
|
[
"Init",
"frame",
"from",
"binary",
"data",
"."
] |
train
|
https://github.com/Julius2342/pyvlx/blob/ee78e1324bcb1be5b8d1a9d05ab5496b72eae848/pyvlx/frames/frame_command_send.py#L98-L101
|
Julius2342/pyvlx
|
pyvlx/frames/frame_command_send.py
|
FrameCommandRunStatusNotification.get_payload
|
def get_payload(self):
"""Return Payload."""
ret = bytes([self.session_id >> 8 & 255, self.session_id & 255])
ret += bytes([self.status_id])
ret += bytes([self.index_id])
ret += bytes([self.node_parameter])
ret += bytes([self.parameter_value >> 8 & 255, self.parameter_value & 255])
# XXX: Missing implementation of run_status, status_reply and information_code
ret += bytes(6)
return ret
|
python
|
def get_payload(self):
"""Return Payload."""
ret = bytes([self.session_id >> 8 & 255, self.session_id & 255])
ret += bytes([self.status_id])
ret += bytes([self.index_id])
ret += bytes([self.node_parameter])
ret += bytes([self.parameter_value >> 8 & 255, self.parameter_value & 255])
# XXX: Missing implementation of run_status, status_reply and information_code
ret += bytes(6)
return ret
|
[
"def",
"get_payload",
"(",
"self",
")",
":",
"ret",
"=",
"bytes",
"(",
"[",
"self",
".",
"session_id",
">>",
"8",
"&",
"255",
",",
"self",
".",
"session_id",
"&",
"255",
"]",
")",
"ret",
"+=",
"bytes",
"(",
"[",
"self",
".",
"status_id",
"]",
")",
"ret",
"+=",
"bytes",
"(",
"[",
"self",
".",
"index_id",
"]",
")",
"ret",
"+=",
"bytes",
"(",
"[",
"self",
".",
"node_parameter",
"]",
")",
"ret",
"+=",
"bytes",
"(",
"[",
"self",
".",
"parameter_value",
">>",
"8",
"&",
"255",
",",
"self",
".",
"parameter_value",
"&",
"255",
"]",
")",
"# XXX: Missing implementation of run_status, status_reply and information_code",
"ret",
"+=",
"bytes",
"(",
"6",
")",
"return",
"ret"
] |
Return Payload.
|
[
"Return",
"Payload",
"."
] |
train
|
https://github.com/Julius2342/pyvlx/blob/ee78e1324bcb1be5b8d1a9d05ab5496b72eae848/pyvlx/frames/frame_command_send.py#L122-L132
|
Julius2342/pyvlx
|
pyvlx/frames/frame_command_send.py
|
FrameCommandRunStatusNotification.from_payload
|
def from_payload(self, payload):
"""Init frame from binary data."""
self.session_id = payload[0]*256 + payload[1]
self.status_id = payload[2]
self.index_id = payload[3]
self.node_parameter = payload[4]
self.parameter_value = payload[5]*256 + payload[6]
|
python
|
def from_payload(self, payload):
"""Init frame from binary data."""
self.session_id = payload[0]*256 + payload[1]
self.status_id = payload[2]
self.index_id = payload[3]
self.node_parameter = payload[4]
self.parameter_value = payload[5]*256 + payload[6]
|
[
"def",
"from_payload",
"(",
"self",
",",
"payload",
")",
":",
"self",
".",
"session_id",
"=",
"payload",
"[",
"0",
"]",
"*",
"256",
"+",
"payload",
"[",
"1",
"]",
"self",
".",
"status_id",
"=",
"payload",
"[",
"2",
"]",
"self",
".",
"index_id",
"=",
"payload",
"[",
"3",
"]",
"self",
".",
"node_parameter",
"=",
"payload",
"[",
"4",
"]",
"self",
".",
"parameter_value",
"=",
"payload",
"[",
"5",
"]",
"*",
"256",
"+",
"payload",
"[",
"6",
"]"
] |
Init frame from binary data.
|
[
"Init",
"frame",
"from",
"binary",
"data",
"."
] |
train
|
https://github.com/Julius2342/pyvlx/blob/ee78e1324bcb1be5b8d1a9d05ab5496b72eae848/pyvlx/frames/frame_command_send.py#L134-L140
|
Julius2342/pyvlx
|
pyvlx/frames/frame_command_send.py
|
FrameCommandRemainingTimeNotification.get_payload
|
def get_payload(self):
"""Return Payload."""
ret = bytes([self.session_id >> 8 & 255, self.session_id & 255])
ret += bytes([self.index_id])
ret += bytes([self.node_parameter])
ret += bytes([self.seconds >> 8 & 255, self.seconds & 255])
return ret
|
python
|
def get_payload(self):
"""Return Payload."""
ret = bytes([self.session_id >> 8 & 255, self.session_id & 255])
ret += bytes([self.index_id])
ret += bytes([self.node_parameter])
ret += bytes([self.seconds >> 8 & 255, self.seconds & 255])
return ret
|
[
"def",
"get_payload",
"(",
"self",
")",
":",
"ret",
"=",
"bytes",
"(",
"[",
"self",
".",
"session_id",
">>",
"8",
"&",
"255",
",",
"self",
".",
"session_id",
"&",
"255",
"]",
")",
"ret",
"+=",
"bytes",
"(",
"[",
"self",
".",
"index_id",
"]",
")",
"ret",
"+=",
"bytes",
"(",
"[",
"self",
".",
"node_parameter",
"]",
")",
"ret",
"+=",
"bytes",
"(",
"[",
"self",
".",
"seconds",
">>",
"8",
"&",
"255",
",",
"self",
".",
"seconds",
"&",
"255",
"]",
")",
"return",
"ret"
] |
Return Payload.
|
[
"Return",
"Payload",
"."
] |
train
|
https://github.com/Julius2342/pyvlx/blob/ee78e1324bcb1be5b8d1a9d05ab5496b72eae848/pyvlx/frames/frame_command_send.py#L164-L170
|
Julius2342/pyvlx
|
pyvlx/frames/frame_command_send.py
|
FrameCommandRemainingTimeNotification.from_payload
|
def from_payload(self, payload):
"""Init frame from binary data."""
self.session_id = payload[0]*256 + payload[1]
self.index_id = payload[2]
self.node_parameter = payload[3]
self.seconds = payload[4]*256 + payload[5]
|
python
|
def from_payload(self, payload):
"""Init frame from binary data."""
self.session_id = payload[0]*256 + payload[1]
self.index_id = payload[2]
self.node_parameter = payload[3]
self.seconds = payload[4]*256 + payload[5]
|
[
"def",
"from_payload",
"(",
"self",
",",
"payload",
")",
":",
"self",
".",
"session_id",
"=",
"payload",
"[",
"0",
"]",
"*",
"256",
"+",
"payload",
"[",
"1",
"]",
"self",
".",
"index_id",
"=",
"payload",
"[",
"2",
"]",
"self",
".",
"node_parameter",
"=",
"payload",
"[",
"3",
"]",
"self",
".",
"seconds",
"=",
"payload",
"[",
"4",
"]",
"*",
"256",
"+",
"payload",
"[",
"5",
"]"
] |
Init frame from binary data.
|
[
"Init",
"frame",
"from",
"binary",
"data",
"."
] |
train
|
https://github.com/Julius2342/pyvlx/blob/ee78e1324bcb1be5b8d1a9d05ab5496b72eae848/pyvlx/frames/frame_command_send.py#L172-L177
|
Julius2342/pyvlx
|
examples/monitor.py
|
main
|
async def main(loop):
"""Log packets from Bus."""
# Setting debug
PYVLXLOG.setLevel(logging.DEBUG)
stream_handler = logging.StreamHandler()
stream_handler.setLevel(logging.DEBUG)
PYVLXLOG.addHandler(stream_handler)
# Connecting to KLF 200
pyvlx = PyVLX('pyvlx.yaml', loop=loop)
await pyvlx.load_scenes()
await pyvlx.load_nodes()
# and wait, increase this timeout if you want to
# log for a longer time.:)
await asyncio.sleep(90)
# Cleanup, KLF 200 is terrible in handling lost connections
await pyvlx.disconnect()
|
python
|
async def main(loop):
"""Log packets from Bus."""
# Setting debug
PYVLXLOG.setLevel(logging.DEBUG)
stream_handler = logging.StreamHandler()
stream_handler.setLevel(logging.DEBUG)
PYVLXLOG.addHandler(stream_handler)
# Connecting to KLF 200
pyvlx = PyVLX('pyvlx.yaml', loop=loop)
await pyvlx.load_scenes()
await pyvlx.load_nodes()
# and wait, increase this timeout if you want to
# log for a longer time.:)
await asyncio.sleep(90)
# Cleanup, KLF 200 is terrible in handling lost connections
await pyvlx.disconnect()
|
[
"async",
"def",
"main",
"(",
"loop",
")",
":",
"# Setting debug",
"PYVLXLOG",
".",
"setLevel",
"(",
"logging",
".",
"DEBUG",
")",
"stream_handler",
"=",
"logging",
".",
"StreamHandler",
"(",
")",
"stream_handler",
".",
"setLevel",
"(",
"logging",
".",
"DEBUG",
")",
"PYVLXLOG",
".",
"addHandler",
"(",
"stream_handler",
")",
"# Connecting to KLF 200",
"pyvlx",
"=",
"PyVLX",
"(",
"'pyvlx.yaml'",
",",
"loop",
"=",
"loop",
")",
"await",
"pyvlx",
".",
"load_scenes",
"(",
")",
"await",
"pyvlx",
".",
"load_nodes",
"(",
")",
"# and wait, increase this timeout if you want to",
"# log for a longer time.:)",
"await",
"asyncio",
".",
"sleep",
"(",
"90",
")",
"# Cleanup, KLF 200 is terrible in handling lost connections",
"await",
"pyvlx",
".",
"disconnect",
"(",
")"
] |
Log packets from Bus.
|
[
"Log",
"packets",
"from",
"Bus",
"."
] |
train
|
https://github.com/Julius2342/pyvlx/blob/ee78e1324bcb1be5b8d1a9d05ab5496b72eae848/examples/monitor.py#L9-L27
|
Julius2342/pyvlx
|
pyvlx/node.py
|
Node.rename
|
async def rename(self, name):
"""Change name of node."""
set_node_name = SetNodeName(pyvlx=self.pyvlx, node_id=self.node_id, name=name)
await set_node_name.do_api_call()
if not set_node_name.success:
raise PyVLXException("Unable to rename node")
self.name = name
|
python
|
async def rename(self, name):
"""Change name of node."""
set_node_name = SetNodeName(pyvlx=self.pyvlx, node_id=self.node_id, name=name)
await set_node_name.do_api_call()
if not set_node_name.success:
raise PyVLXException("Unable to rename node")
self.name = name
|
[
"async",
"def",
"rename",
"(",
"self",
",",
"name",
")",
":",
"set_node_name",
"=",
"SetNodeName",
"(",
"pyvlx",
"=",
"self",
".",
"pyvlx",
",",
"node_id",
"=",
"self",
".",
"node_id",
",",
"name",
"=",
"name",
")",
"await",
"set_node_name",
".",
"do_api_call",
"(",
")",
"if",
"not",
"set_node_name",
".",
"success",
":",
"raise",
"PyVLXException",
"(",
"\"Unable to rename node\"",
")",
"self",
".",
"name",
"=",
"name"
] |
Change name of node.
|
[
"Change",
"name",
"of",
"node",
"."
] |
train
|
https://github.com/Julius2342/pyvlx/blob/ee78e1324bcb1be5b8d1a9d05ab5496b72eae848/pyvlx/node.py#L36-L42
|
Julius2342/pyvlx
|
pyvlx/opening_device.py
|
OpeningDevice.set_position
|
async def set_position(self, position, wait_for_completion=True):
"""Set window to desired position.
Parameters:
* position: Position object containing the target position.
* wait_for_completion: If set, function will return
after device has reached target position.
"""
command_send = CommandSend(
pyvlx=self.pyvlx,
wait_for_completion=wait_for_completion,
node_id=self.node_id,
parameter=position)
await command_send.do_api_call()
if not command_send.success:
raise PyVLXException("Unable to send command")
await self.after_update()
|
python
|
async def set_position(self, position, wait_for_completion=True):
"""Set window to desired position.
Parameters:
* position: Position object containing the target position.
* wait_for_completion: If set, function will return
after device has reached target position.
"""
command_send = CommandSend(
pyvlx=self.pyvlx,
wait_for_completion=wait_for_completion,
node_id=self.node_id,
parameter=position)
await command_send.do_api_call()
if not command_send.success:
raise PyVLXException("Unable to send command")
await self.after_update()
|
[
"async",
"def",
"set_position",
"(",
"self",
",",
"position",
",",
"wait_for_completion",
"=",
"True",
")",
":",
"command_send",
"=",
"CommandSend",
"(",
"pyvlx",
"=",
"self",
".",
"pyvlx",
",",
"wait_for_completion",
"=",
"wait_for_completion",
",",
"node_id",
"=",
"self",
".",
"node_id",
",",
"parameter",
"=",
"position",
")",
"await",
"command_send",
".",
"do_api_call",
"(",
")",
"if",
"not",
"command_send",
".",
"success",
":",
"raise",
"PyVLXException",
"(",
"\"Unable to send command\"",
")",
"await",
"self",
".",
"after_update",
"(",
")"
] |
Set window to desired position.
Parameters:
* position: Position object containing the target position.
* wait_for_completion: If set, function will return
after device has reached target position.
|
[
"Set",
"window",
"to",
"desired",
"position",
"."
] |
train
|
https://github.com/Julius2342/pyvlx/blob/ee78e1324bcb1be5b8d1a9d05ab5496b72eae848/pyvlx/opening_device.py#L24-L41
|
Julius2342/pyvlx
|
pyvlx/opening_device.py
|
OpeningDevice.open
|
async def open(self, wait_for_completion=True):
"""Open window.
Parameters:
* wait_for_completion: If set, function will return
after device has reached target position.
"""
await self.set_position(
position=Position(position_percent=0),
wait_for_completion=wait_for_completion)
|
python
|
async def open(self, wait_for_completion=True):
"""Open window.
Parameters:
* wait_for_completion: If set, function will return
after device has reached target position.
"""
await self.set_position(
position=Position(position_percent=0),
wait_for_completion=wait_for_completion)
|
[
"async",
"def",
"open",
"(",
"self",
",",
"wait_for_completion",
"=",
"True",
")",
":",
"await",
"self",
".",
"set_position",
"(",
"position",
"=",
"Position",
"(",
"position_percent",
"=",
"0",
")",
",",
"wait_for_completion",
"=",
"wait_for_completion",
")"
] |
Open window.
Parameters:
* wait_for_completion: If set, function will return
after device has reached target position.
|
[
"Open",
"window",
"."
] |
train
|
https://github.com/Julius2342/pyvlx/blob/ee78e1324bcb1be5b8d1a9d05ab5496b72eae848/pyvlx/opening_device.py#L43-L53
|
Julius2342/pyvlx
|
pyvlx/opening_device.py
|
OpeningDevice.close
|
async def close(self, wait_for_completion=True):
"""Close window.
Parameters:
* wait_for_completion: If set, function will return
after device has reached target position.
"""
await self.set_position(
position=Position(position_percent=100),
wait_for_completion=wait_for_completion)
|
python
|
async def close(self, wait_for_completion=True):
"""Close window.
Parameters:
* wait_for_completion: If set, function will return
after device has reached target position.
"""
await self.set_position(
position=Position(position_percent=100),
wait_for_completion=wait_for_completion)
|
[
"async",
"def",
"close",
"(",
"self",
",",
"wait_for_completion",
"=",
"True",
")",
":",
"await",
"self",
".",
"set_position",
"(",
"position",
"=",
"Position",
"(",
"position_percent",
"=",
"100",
")",
",",
"wait_for_completion",
"=",
"wait_for_completion",
")"
] |
Close window.
Parameters:
* wait_for_completion: If set, function will return
after device has reached target position.
|
[
"Close",
"window",
"."
] |
train
|
https://github.com/Julius2342/pyvlx/blob/ee78e1324bcb1be5b8d1a9d05ab5496b72eae848/pyvlx/opening_device.py#L55-L65
|
Julius2342/pyvlx
|
pyvlx/opening_device.py
|
OpeningDevice.stop
|
async def stop(self, wait_for_completion=True):
"""Stop window.
Parameters:
* wait_for_completion: If set, function will return
after device has reached target position.
"""
await self.set_position(
position=CurrentPosition(),
wait_for_completion=wait_for_completion)
|
python
|
async def stop(self, wait_for_completion=True):
"""Stop window.
Parameters:
* wait_for_completion: If set, function will return
after device has reached target position.
"""
await self.set_position(
position=CurrentPosition(),
wait_for_completion=wait_for_completion)
|
[
"async",
"def",
"stop",
"(",
"self",
",",
"wait_for_completion",
"=",
"True",
")",
":",
"await",
"self",
".",
"set_position",
"(",
"position",
"=",
"CurrentPosition",
"(",
")",
",",
"wait_for_completion",
"=",
"wait_for_completion",
")"
] |
Stop window.
Parameters:
* wait_for_completion: If set, function will return
after device has reached target position.
|
[
"Stop",
"window",
"."
] |
train
|
https://github.com/Julius2342/pyvlx/blob/ee78e1324bcb1be5b8d1a9d05ab5496b72eae848/pyvlx/opening_device.py#L67-L77
|
spacetelescope/synphot_refactor
|
synphot/models.py
|
_get_sampleset
|
def _get_sampleset(model):
"""Return sampleset of a model or `None` if undefined.
Model could be a real model or evaluated sampleset."""
if isinstance(model, Model):
if hasattr(model, 'sampleset'):
w = model.sampleset()
else:
w = None
else:
w = model # Already a sampleset
return w
|
python
|
def _get_sampleset(model):
"""Return sampleset of a model or `None` if undefined.
Model could be a real model or evaluated sampleset."""
if isinstance(model, Model):
if hasattr(model, 'sampleset'):
w = model.sampleset()
else:
w = None
else:
w = model # Already a sampleset
return w
|
[
"def",
"_get_sampleset",
"(",
"model",
")",
":",
"if",
"isinstance",
"(",
"model",
",",
"Model",
")",
":",
"if",
"hasattr",
"(",
"model",
",",
"'sampleset'",
")",
":",
"w",
"=",
"model",
".",
"sampleset",
"(",
")",
"else",
":",
"w",
"=",
"None",
"else",
":",
"w",
"=",
"model",
"# Already a sampleset",
"return",
"w"
] |
Return sampleset of a model or `None` if undefined.
Model could be a real model or evaluated sampleset.
|
[
"Return",
"sampleset",
"of",
"a",
"model",
"or",
"None",
"if",
"undefined",
".",
"Model",
"could",
"be",
"a",
"real",
"model",
"or",
"evaluated",
"sampleset",
"."
] |
train
|
https://github.com/spacetelescope/synphot_refactor/blob/9c064f3cff0c41dd8acadc0f67c6350931275b9f/synphot/models.py#L654-L664
|
spacetelescope/synphot_refactor
|
synphot/models.py
|
_merge_sampleset
|
def _merge_sampleset(model1, model2):
"""Simple merge of samplesets."""
w1 = _get_sampleset(model1)
w2 = _get_sampleset(model2)
return merge_wavelengths(w1, w2)
|
python
|
def _merge_sampleset(model1, model2):
"""Simple merge of samplesets."""
w1 = _get_sampleset(model1)
w2 = _get_sampleset(model2)
return merge_wavelengths(w1, w2)
|
[
"def",
"_merge_sampleset",
"(",
"model1",
",",
"model2",
")",
":",
"w1",
"=",
"_get_sampleset",
"(",
"model1",
")",
"w2",
"=",
"_get_sampleset",
"(",
"model2",
")",
"return",
"merge_wavelengths",
"(",
"w1",
",",
"w2",
")"
] |
Simple merge of samplesets.
|
[
"Simple",
"merge",
"of",
"samplesets",
"."
] |
train
|
https://github.com/spacetelescope/synphot_refactor/blob/9c064f3cff0c41dd8acadc0f67c6350931275b9f/synphot/models.py#L667-L671
|
spacetelescope/synphot_refactor
|
synphot/models.py
|
_shift_wavelengths
|
def _shift_wavelengths(model1, model2):
"""One of the models is either ``RedshiftScaleFactor`` or ``Scale``.
Possible combos::
RedshiftScaleFactor | Model
Scale | Model
Model | Scale
"""
if isinstance(model1, _models.RedshiftScaleFactor):
val = _get_sampleset(model2)
if val is None:
w = val
else:
w = model1.inverse(val)
elif isinstance(model1, _models.Scale):
w = _get_sampleset(model2)
else:
w = _get_sampleset(model1)
return w
|
python
|
def _shift_wavelengths(model1, model2):
"""One of the models is either ``RedshiftScaleFactor`` or ``Scale``.
Possible combos::
RedshiftScaleFactor | Model
Scale | Model
Model | Scale
"""
if isinstance(model1, _models.RedshiftScaleFactor):
val = _get_sampleset(model2)
if val is None:
w = val
else:
w = model1.inverse(val)
elif isinstance(model1, _models.Scale):
w = _get_sampleset(model2)
else:
w = _get_sampleset(model1)
return w
|
[
"def",
"_shift_wavelengths",
"(",
"model1",
",",
"model2",
")",
":",
"if",
"isinstance",
"(",
"model1",
",",
"_models",
".",
"RedshiftScaleFactor",
")",
":",
"val",
"=",
"_get_sampleset",
"(",
"model2",
")",
"if",
"val",
"is",
"None",
":",
"w",
"=",
"val",
"else",
":",
"w",
"=",
"model1",
".",
"inverse",
"(",
"val",
")",
"elif",
"isinstance",
"(",
"model1",
",",
"_models",
".",
"Scale",
")",
":",
"w",
"=",
"_get_sampleset",
"(",
"model2",
")",
"else",
":",
"w",
"=",
"_get_sampleset",
"(",
"model1",
")",
"return",
"w"
] |
One of the models is either ``RedshiftScaleFactor`` or ``Scale``.
Possible combos::
RedshiftScaleFactor | Model
Scale | Model
Model | Scale
|
[
"One",
"of",
"the",
"models",
"is",
"either",
"RedshiftScaleFactor",
"or",
"Scale",
"."
] |
train
|
https://github.com/spacetelescope/synphot_refactor/blob/9c064f3cff0c41dd8acadc0f67c6350931275b9f/synphot/models.py#L674-L694
|
spacetelescope/synphot_refactor
|
synphot/models.py
|
get_waveset
|
def get_waveset(model):
"""Get optimal wavelengths for sampling a given model.
Parameters
----------
model : `~astropy.modeling.Model`
Model.
Returns
-------
waveset : array-like or `None`
Optimal wavelengths. `None` if undefined.
Raises
------
synphot.exceptions.SynphotError
Invalid model.
"""
if not isinstance(model, Model):
raise SynphotError('{0} is not a model.'.format(model))
if isinstance(model, _CompoundModel):
waveset = model._tree.evaluate(WAVESET_OPERATORS, getter=None)
else:
waveset = _get_sampleset(model)
return waveset
|
python
|
def get_waveset(model):
"""Get optimal wavelengths for sampling a given model.
Parameters
----------
model : `~astropy.modeling.Model`
Model.
Returns
-------
waveset : array-like or `None`
Optimal wavelengths. `None` if undefined.
Raises
------
synphot.exceptions.SynphotError
Invalid model.
"""
if not isinstance(model, Model):
raise SynphotError('{0} is not a model.'.format(model))
if isinstance(model, _CompoundModel):
waveset = model._tree.evaluate(WAVESET_OPERATORS, getter=None)
else:
waveset = _get_sampleset(model)
return waveset
|
[
"def",
"get_waveset",
"(",
"model",
")",
":",
"if",
"not",
"isinstance",
"(",
"model",
",",
"Model",
")",
":",
"raise",
"SynphotError",
"(",
"'{0} is not a model.'",
".",
"format",
"(",
"model",
")",
")",
"if",
"isinstance",
"(",
"model",
",",
"_CompoundModel",
")",
":",
"waveset",
"=",
"model",
".",
"_tree",
".",
"evaluate",
"(",
"WAVESET_OPERATORS",
",",
"getter",
"=",
"None",
")",
"else",
":",
"waveset",
"=",
"_get_sampleset",
"(",
"model",
")",
"return",
"waveset"
] |
Get optimal wavelengths for sampling a given model.
Parameters
----------
model : `~astropy.modeling.Model`
Model.
Returns
-------
waveset : array-like or `None`
Optimal wavelengths. `None` if undefined.
Raises
------
synphot.exceptions.SynphotError
Invalid model.
|
[
"Get",
"optimal",
"wavelengths",
"for",
"sampling",
"a",
"given",
"model",
"."
] |
train
|
https://github.com/spacetelescope/synphot_refactor/blob/9c064f3cff0c41dd8acadc0f67c6350931275b9f/synphot/models.py#L708-L735
|
spacetelescope/synphot_refactor
|
synphot/models.py
|
_get_meta
|
def _get_meta(model):
"""Return metadata of a model.
Model could be a real model or evaluated metadata."""
if isinstance(model, Model):
w = model.meta
else:
w = model # Already metadata
return w
|
python
|
def _get_meta(model):
"""Return metadata of a model.
Model could be a real model or evaluated metadata."""
if isinstance(model, Model):
w = model.meta
else:
w = model # Already metadata
return w
|
[
"def",
"_get_meta",
"(",
"model",
")",
":",
"if",
"isinstance",
"(",
"model",
",",
"Model",
")",
":",
"w",
"=",
"model",
".",
"meta",
"else",
":",
"w",
"=",
"model",
"# Already metadata",
"return",
"w"
] |
Return metadata of a model.
Model could be a real model or evaluated metadata.
|
[
"Return",
"metadata",
"of",
"a",
"model",
".",
"Model",
"could",
"be",
"a",
"real",
"model",
"or",
"evaluated",
"metadata",
"."
] |
train
|
https://github.com/spacetelescope/synphot_refactor/blob/9c064f3cff0c41dd8acadc0f67c6350931275b9f/synphot/models.py#L744-L751
|
spacetelescope/synphot_refactor
|
synphot/models.py
|
_merge_meta
|
def _merge_meta(model1, model2):
"""Simple merge of samplesets."""
w1 = _get_meta(model1)
w2 = _get_meta(model2)
return metadata.merge(w1, w2, metadata_conflicts='silent')
|
python
|
def _merge_meta(model1, model2):
"""Simple merge of samplesets."""
w1 = _get_meta(model1)
w2 = _get_meta(model2)
return metadata.merge(w1, w2, metadata_conflicts='silent')
|
[
"def",
"_merge_meta",
"(",
"model1",
",",
"model2",
")",
":",
"w1",
"=",
"_get_meta",
"(",
"model1",
")",
"w2",
"=",
"_get_meta",
"(",
"model2",
")",
"return",
"metadata",
".",
"merge",
"(",
"w1",
",",
"w2",
",",
"metadata_conflicts",
"=",
"'silent'",
")"
] |
Simple merge of samplesets.
|
[
"Simple",
"merge",
"of",
"samplesets",
"."
] |
train
|
https://github.com/spacetelescope/synphot_refactor/blob/9c064f3cff0c41dd8acadc0f67c6350931275b9f/synphot/models.py#L754-L758
|
spacetelescope/synphot_refactor
|
synphot/models.py
|
get_metadata
|
def get_metadata(model):
"""Get metadata for a given model.
Parameters
----------
model : `~astropy.modeling.Model`
Model.
Returns
-------
metadata : dict
Metadata for the model.
Raises
------
synphot.exceptions.SynphotError
Invalid model.
"""
if not isinstance(model, Model):
raise SynphotError('{0} is not a model.'.format(model))
if isinstance(model, _CompoundModel):
metadata = model._tree.evaluate(METADATA_OPERATORS, getter=None)
else:
metadata = deepcopy(model.meta)
return metadata
|
python
|
def get_metadata(model):
"""Get metadata for a given model.
Parameters
----------
model : `~astropy.modeling.Model`
Model.
Returns
-------
metadata : dict
Metadata for the model.
Raises
------
synphot.exceptions.SynphotError
Invalid model.
"""
if not isinstance(model, Model):
raise SynphotError('{0} is not a model.'.format(model))
if isinstance(model, _CompoundModel):
metadata = model._tree.evaluate(METADATA_OPERATORS, getter=None)
else:
metadata = deepcopy(model.meta)
return metadata
|
[
"def",
"get_metadata",
"(",
"model",
")",
":",
"if",
"not",
"isinstance",
"(",
"model",
",",
"Model",
")",
":",
"raise",
"SynphotError",
"(",
"'{0} is not a model.'",
".",
"format",
"(",
"model",
")",
")",
"if",
"isinstance",
"(",
"model",
",",
"_CompoundModel",
")",
":",
"metadata",
"=",
"model",
".",
"_tree",
".",
"evaluate",
"(",
"METADATA_OPERATORS",
",",
"getter",
"=",
"None",
")",
"else",
":",
"metadata",
"=",
"deepcopy",
"(",
"model",
".",
"meta",
")",
"return",
"metadata"
] |
Get metadata for a given model.
Parameters
----------
model : `~astropy.modeling.Model`
Model.
Returns
-------
metadata : dict
Metadata for the model.
Raises
------
synphot.exceptions.SynphotError
Invalid model.
|
[
"Get",
"metadata",
"for",
"a",
"given",
"model",
"."
] |
train
|
https://github.com/spacetelescope/synphot_refactor/blob/9c064f3cff0c41dd8acadc0f67c6350931275b9f/synphot/models.py#L761-L788
|
spacetelescope/synphot_refactor
|
synphot/models.py
|
BlackBody1D.lambda_max
|
def lambda_max(self):
"""Peak wavelength in Angstrom when the curve is expressed as
power density."""
return ((const.b_wien.value / self.temperature) * u.m).to(u.AA).value
|
python
|
def lambda_max(self):
"""Peak wavelength in Angstrom when the curve is expressed as
power density."""
return ((const.b_wien.value / self.temperature) * u.m).to(u.AA).value
|
[
"def",
"lambda_max",
"(",
"self",
")",
":",
"return",
"(",
"(",
"const",
".",
"b_wien",
".",
"value",
"/",
"self",
".",
"temperature",
")",
"*",
"u",
".",
"m",
")",
".",
"to",
"(",
"u",
".",
"AA",
")",
".",
"value"
] |
Peak wavelength in Angstrom when the curve is expressed as
power density.
|
[
"Peak",
"wavelength",
"in",
"Angstrom",
"when",
"the",
"curve",
"is",
"expressed",
"as",
"power",
"density",
"."
] |
train
|
https://github.com/spacetelescope/synphot_refactor/blob/9c064f3cff0c41dd8acadc0f67c6350931275b9f/synphot/models.py#L53-L56
|
spacetelescope/synphot_refactor
|
synphot/models.py
|
BlackBody1D.bounding_box
|
def bounding_box(self, factor=10.0):
"""Tuple defining the default ``bounding_box`` limits,
``(x_low, x_high)``.
.. math::
x_{\\textnormal{low}} = 0
x_{\\textnormal{high}} = \\log(\\lambda_{\\textnormal{max}} \\;\
(1 + \\textnormal{factor}))
Parameters
----------
factor : float
Used to calculate ``x_high``.
"""
w0 = self.lambda_max
return (w0 * 0, np.log10(w0 + factor * w0))
|
python
|
def bounding_box(self, factor=10.0):
"""Tuple defining the default ``bounding_box`` limits,
``(x_low, x_high)``.
.. math::
x_{\\textnormal{low}} = 0
x_{\\textnormal{high}} = \\log(\\lambda_{\\textnormal{max}} \\;\
(1 + \\textnormal{factor}))
Parameters
----------
factor : float
Used to calculate ``x_high``.
"""
w0 = self.lambda_max
return (w0 * 0, np.log10(w0 + factor * w0))
|
[
"def",
"bounding_box",
"(",
"self",
",",
"factor",
"=",
"10.0",
")",
":",
"w0",
"=",
"self",
".",
"lambda_max",
"return",
"(",
"w0",
"*",
"0",
",",
"np",
".",
"log10",
"(",
"w0",
"+",
"factor",
"*",
"w0",
")",
")"
] |
Tuple defining the default ``bounding_box`` limits,
``(x_low, x_high)``.
.. math::
x_{\\textnormal{low}} = 0
x_{\\textnormal{high}} = \\log(\\lambda_{\\textnormal{max}} \\;\
(1 + \\textnormal{factor}))
Parameters
----------
factor : float
Used to calculate ``x_high``.
|
[
"Tuple",
"defining",
"the",
"default",
"bounding_box",
"limits",
"(",
"x_low",
"x_high",
")",
"."
] |
train
|
https://github.com/spacetelescope/synphot_refactor/blob/9c064f3cff0c41dd8acadc0f67c6350931275b9f/synphot/models.py#L58-L76
|
spacetelescope/synphot_refactor
|
synphot/models.py
|
BlackBody1D.sampleset
|
def sampleset(self, factor_bbox=10.0, num=1000):
"""Return ``x`` array that samples the feature.
Parameters
----------
factor_bbox : float
Factor for ``bounding_box`` calculations.
num : int
Number of points to generate.
"""
w1, w2 = self.bounding_box(factor=factor_bbox)
if self._n_models == 1:
w = np.logspace(w1, w2, num)
else:
w = list(map(partial(np.logspace, num=num), w1, w2))
return np.asarray(w)
|
python
|
def sampleset(self, factor_bbox=10.0, num=1000):
"""Return ``x`` array that samples the feature.
Parameters
----------
factor_bbox : float
Factor for ``bounding_box`` calculations.
num : int
Number of points to generate.
"""
w1, w2 = self.bounding_box(factor=factor_bbox)
if self._n_models == 1:
w = np.logspace(w1, w2, num)
else:
w = list(map(partial(np.logspace, num=num), w1, w2))
return np.asarray(w)
|
[
"def",
"sampleset",
"(",
"self",
",",
"factor_bbox",
"=",
"10.0",
",",
"num",
"=",
"1000",
")",
":",
"w1",
",",
"w2",
"=",
"self",
".",
"bounding_box",
"(",
"factor",
"=",
"factor_bbox",
")",
"if",
"self",
".",
"_n_models",
"==",
"1",
":",
"w",
"=",
"np",
".",
"logspace",
"(",
"w1",
",",
"w2",
",",
"num",
")",
"else",
":",
"w",
"=",
"list",
"(",
"map",
"(",
"partial",
"(",
"np",
".",
"logspace",
",",
"num",
"=",
"num",
")",
",",
"w1",
",",
"w2",
")",
")",
"return",
"np",
".",
"asarray",
"(",
"w",
")"
] |
Return ``x`` array that samples the feature.
Parameters
----------
factor_bbox : float
Factor for ``bounding_box`` calculations.
num : int
Number of points to generate.
|
[
"Return",
"x",
"array",
"that",
"samples",
"the",
"feature",
"."
] |
train
|
https://github.com/spacetelescope/synphot_refactor/blob/9c064f3cff0c41dd8acadc0f67c6350931275b9f/synphot/models.py#L78-L97
|
spacetelescope/synphot_refactor
|
synphot/models.py
|
BlackBody1D.evaluate
|
def evaluate(x, temperature):
"""Evaluate the model.
Parameters
----------
x : number or ndarray
Wavelengths in Angstrom.
temperature : number
Temperature in Kelvin.
Returns
-------
y : number or ndarray
Blackbody radiation in PHOTLAM per steradian.
"""
if ASTROPY_LT_2_0:
from astropy.analytic_functions.blackbody import blackbody_nu
else:
from astropy.modeling.blackbody import blackbody_nu
# Silence Numpy
old_np_err_cfg = np.seterr(all='ignore')
wave = np.ascontiguousarray(x) * u.AA
bbnu_flux = blackbody_nu(wave, temperature)
bbflux = (bbnu_flux * u.sr).to(
units.PHOTLAM, u.spectral_density(wave)) / u.sr # PHOTLAM/sr
# Restore Numpy settings
np.seterr(**old_np_err_cfg)
return bbflux.value
|
python
|
def evaluate(x, temperature):
"""Evaluate the model.
Parameters
----------
x : number or ndarray
Wavelengths in Angstrom.
temperature : number
Temperature in Kelvin.
Returns
-------
y : number or ndarray
Blackbody radiation in PHOTLAM per steradian.
"""
if ASTROPY_LT_2_0:
from astropy.analytic_functions.blackbody import blackbody_nu
else:
from astropy.modeling.blackbody import blackbody_nu
# Silence Numpy
old_np_err_cfg = np.seterr(all='ignore')
wave = np.ascontiguousarray(x) * u.AA
bbnu_flux = blackbody_nu(wave, temperature)
bbflux = (bbnu_flux * u.sr).to(
units.PHOTLAM, u.spectral_density(wave)) / u.sr # PHOTLAM/sr
# Restore Numpy settings
np.seterr(**old_np_err_cfg)
return bbflux.value
|
[
"def",
"evaluate",
"(",
"x",
",",
"temperature",
")",
":",
"if",
"ASTROPY_LT_2_0",
":",
"from",
"astropy",
".",
"analytic_functions",
".",
"blackbody",
"import",
"blackbody_nu",
"else",
":",
"from",
"astropy",
".",
"modeling",
".",
"blackbody",
"import",
"blackbody_nu",
"# Silence Numpy",
"old_np_err_cfg",
"=",
"np",
".",
"seterr",
"(",
"all",
"=",
"'ignore'",
")",
"wave",
"=",
"np",
".",
"ascontiguousarray",
"(",
"x",
")",
"*",
"u",
".",
"AA",
"bbnu_flux",
"=",
"blackbody_nu",
"(",
"wave",
",",
"temperature",
")",
"bbflux",
"=",
"(",
"bbnu_flux",
"*",
"u",
".",
"sr",
")",
".",
"to",
"(",
"units",
".",
"PHOTLAM",
",",
"u",
".",
"spectral_density",
"(",
"wave",
")",
")",
"/",
"u",
".",
"sr",
"# PHOTLAM/sr",
"# Restore Numpy settings",
"np",
".",
"seterr",
"(",
"*",
"*",
"old_np_err_cfg",
")",
"return",
"bbflux",
".",
"value"
] |
Evaluate the model.
Parameters
----------
x : number or ndarray
Wavelengths in Angstrom.
temperature : number
Temperature in Kelvin.
Returns
-------
y : number or ndarray
Blackbody radiation in PHOTLAM per steradian.
|
[
"Evaluate",
"the",
"model",
"."
] |
train
|
https://github.com/spacetelescope/synphot_refactor/blob/9c064f3cff0c41dd8acadc0f67c6350931275b9f/synphot/models.py#L100-L133
|
spacetelescope/synphot_refactor
|
synphot/models.py
|
BlackBodyNorm1D.evaluate
|
def evaluate(self, x, temperature):
"""Evaluate the model.
Parameters
----------
x : number or ndarray
Wavelengths in Angstrom.
temperature : number
Temperature in Kelvin.
Returns
-------
y : number or ndarray
Blackbody radiation in PHOTLAM.
"""
bbflux = super(BlackBodyNorm1D, self).evaluate(x, temperature)
return bbflux * self._omega
|
python
|
def evaluate(self, x, temperature):
"""Evaluate the model.
Parameters
----------
x : number or ndarray
Wavelengths in Angstrom.
temperature : number
Temperature in Kelvin.
Returns
-------
y : number or ndarray
Blackbody radiation in PHOTLAM.
"""
bbflux = super(BlackBodyNorm1D, self).evaluate(x, temperature)
return bbflux * self._omega
|
[
"def",
"evaluate",
"(",
"self",
",",
"x",
",",
"temperature",
")",
":",
"bbflux",
"=",
"super",
"(",
"BlackBodyNorm1D",
",",
"self",
")",
".",
"evaluate",
"(",
"x",
",",
"temperature",
")",
"return",
"bbflux",
"*",
"self",
".",
"_omega"
] |
Evaluate the model.
Parameters
----------
x : number or ndarray
Wavelengths in Angstrom.
temperature : number
Temperature in Kelvin.
Returns
-------
y : number or ndarray
Blackbody radiation in PHOTLAM.
|
[
"Evaluate",
"the",
"model",
"."
] |
train
|
https://github.com/spacetelescope/synphot_refactor/blob/9c064f3cff0c41dd8acadc0f67c6350931275b9f/synphot/models.py#L157-L175
|
spacetelescope/synphot_refactor
|
synphot/models.py
|
Box1D._calc_sampleset
|
def _calc_sampleset(w1, w2, step, minimal):
"""Calculate sampleset for each model."""
if minimal:
arr = [w1 - step, w1, w2, w2 + step]
else:
arr = np.arange(w1 - step, w2 + step + step, step)
return arr
|
python
|
def _calc_sampleset(w1, w2, step, minimal):
"""Calculate sampleset for each model."""
if minimal:
arr = [w1 - step, w1, w2, w2 + step]
else:
arr = np.arange(w1 - step, w2 + step + step, step)
return arr
|
[
"def",
"_calc_sampleset",
"(",
"w1",
",",
"w2",
",",
"step",
",",
"minimal",
")",
":",
"if",
"minimal",
":",
"arr",
"=",
"[",
"w1",
"-",
"step",
",",
"w1",
",",
"w2",
",",
"w2",
"+",
"step",
"]",
"else",
":",
"arr",
"=",
"np",
".",
"arange",
"(",
"w1",
"-",
"step",
",",
"w2",
"+",
"step",
"+",
"step",
",",
"step",
")",
"return",
"arr"
] |
Calculate sampleset for each model.
|
[
"Calculate",
"sampleset",
"for",
"each",
"model",
"."
] |
train
|
https://github.com/spacetelescope/synphot_refactor/blob/9c064f3cff0c41dd8acadc0f67c6350931275b9f/synphot/models.py#L184-L191
|
spacetelescope/synphot_refactor
|
synphot/models.py
|
Box1D.sampleset
|
def sampleset(self, step=0.01, minimal=False):
"""Return ``x`` array that samples the feature.
Parameters
----------
step : float
Distance of first and last points w.r.t. bounding box.
minimal : bool
Only return the minimal points needed to define the box;
i.e., box edges and a point outside on each side.
"""
w1, w2 = self.bounding_box
if self._n_models == 1:
w = self._calc_sampleset(w1, w2, step, minimal)
else:
w = list(map(partial(
self._calc_sampleset, step=step, minimal=minimal), w1, w2))
return np.asarray(w)
|
python
|
def sampleset(self, step=0.01, minimal=False):
"""Return ``x`` array that samples the feature.
Parameters
----------
step : float
Distance of first and last points w.r.t. bounding box.
minimal : bool
Only return the minimal points needed to define the box;
i.e., box edges and a point outside on each side.
"""
w1, w2 = self.bounding_box
if self._n_models == 1:
w = self._calc_sampleset(w1, w2, step, minimal)
else:
w = list(map(partial(
self._calc_sampleset, step=step, minimal=minimal), w1, w2))
return np.asarray(w)
|
[
"def",
"sampleset",
"(",
"self",
",",
"step",
"=",
"0.01",
",",
"minimal",
"=",
"False",
")",
":",
"w1",
",",
"w2",
"=",
"self",
".",
"bounding_box",
"if",
"self",
".",
"_n_models",
"==",
"1",
":",
"w",
"=",
"self",
".",
"_calc_sampleset",
"(",
"w1",
",",
"w2",
",",
"step",
",",
"minimal",
")",
"else",
":",
"w",
"=",
"list",
"(",
"map",
"(",
"partial",
"(",
"self",
".",
"_calc_sampleset",
",",
"step",
"=",
"step",
",",
"minimal",
"=",
"minimal",
")",
",",
"w1",
",",
"w2",
")",
")",
"return",
"np",
".",
"asarray",
"(",
"w",
")"
] |
Return ``x`` array that samples the feature.
Parameters
----------
step : float
Distance of first and last points w.r.t. bounding box.
minimal : bool
Only return the minimal points needed to define the box;
i.e., box edges and a point outside on each side.
|
[
"Return",
"x",
"array",
"that",
"samples",
"the",
"feature",
"."
] |
train
|
https://github.com/spacetelescope/synphot_refactor/blob/9c064f3cff0c41dd8acadc0f67c6350931275b9f/synphot/models.py#L193-L214
|
spacetelescope/synphot_refactor
|
synphot/models.py
|
ConstFlux1D.evaluate
|
def evaluate(self, x, *args):
"""One dimensional constant flux model function.
Parameters
----------
x : number or ndarray
Wavelengths in Angstrom.
Returns
-------
y : number or ndarray
Flux in PHOTLAM.
"""
a = (self.amplitude * np.ones_like(x)) * self._flux_unit
y = units.convert_flux(x, a, units.PHOTLAM)
return y.value
|
python
|
def evaluate(self, x, *args):
"""One dimensional constant flux model function.
Parameters
----------
x : number or ndarray
Wavelengths in Angstrom.
Returns
-------
y : number or ndarray
Flux in PHOTLAM.
"""
a = (self.amplitude * np.ones_like(x)) * self._flux_unit
y = units.convert_flux(x, a, units.PHOTLAM)
return y.value
|
[
"def",
"evaluate",
"(",
"self",
",",
"x",
",",
"*",
"args",
")",
":",
"a",
"=",
"(",
"self",
".",
"amplitude",
"*",
"np",
".",
"ones_like",
"(",
"x",
")",
")",
"*",
"self",
".",
"_flux_unit",
"y",
"=",
"units",
".",
"convert_flux",
"(",
"x",
",",
"a",
",",
"units",
".",
"PHOTLAM",
")",
"return",
"y",
".",
"value"
] |
One dimensional constant flux model function.
Parameters
----------
x : number or ndarray
Wavelengths in Angstrom.
Returns
-------
y : number or ndarray
Flux in PHOTLAM.
|
[
"One",
"dimensional",
"constant",
"flux",
"model",
"function",
"."
] |
train
|
https://github.com/spacetelescope/synphot_refactor/blob/9c064f3cff0c41dd8acadc0f67c6350931275b9f/synphot/models.py#L252-L268
|
spacetelescope/synphot_refactor
|
synphot/models.py
|
Empirical1D._process_neg_flux
|
def _process_neg_flux(self, x, y):
"""Remove negative flux."""
if self._keep_neg: # Nothing to do
return y
old_y = None
if np.isscalar(y): # pragma: no cover
if y < 0:
n_neg = 1
old_x = x
old_y = y
y = 0
else:
x = np.asarray(x) # In case input is just pure list
y = np.asarray(y)
i = np.where(y < 0)
n_neg = len(i[0])
if n_neg > 0:
old_x = x[i]
old_y = y[i]
y[i] = 0
if old_y is not None:
warn_str = ('{0} bin(s) contained negative flux or throughput'
'; it/they will be set to zero.'.format(n_neg))
warn_str += '\n points: {0}\n lookup_table: {1}'.format(
old_x, old_y) # Extra info
self.meta['warnings'].update({'NegativeFlux': warn_str})
warnings.warn(warn_str, AstropyUserWarning)
return y
|
python
|
def _process_neg_flux(self, x, y):
"""Remove negative flux."""
if self._keep_neg: # Nothing to do
return y
old_y = None
if np.isscalar(y): # pragma: no cover
if y < 0:
n_neg = 1
old_x = x
old_y = y
y = 0
else:
x = np.asarray(x) # In case input is just pure list
y = np.asarray(y)
i = np.where(y < 0)
n_neg = len(i[0])
if n_neg > 0:
old_x = x[i]
old_y = y[i]
y[i] = 0
if old_y is not None:
warn_str = ('{0} bin(s) contained negative flux or throughput'
'; it/they will be set to zero.'.format(n_neg))
warn_str += '\n points: {0}\n lookup_table: {1}'.format(
old_x, old_y) # Extra info
self.meta['warnings'].update({'NegativeFlux': warn_str})
warnings.warn(warn_str, AstropyUserWarning)
return y
|
[
"def",
"_process_neg_flux",
"(",
"self",
",",
"x",
",",
"y",
")",
":",
"if",
"self",
".",
"_keep_neg",
":",
"# Nothing to do",
"return",
"y",
"old_y",
"=",
"None",
"if",
"np",
".",
"isscalar",
"(",
"y",
")",
":",
"# pragma: no cover",
"if",
"y",
"<",
"0",
":",
"n_neg",
"=",
"1",
"old_x",
"=",
"x",
"old_y",
"=",
"y",
"y",
"=",
"0",
"else",
":",
"x",
"=",
"np",
".",
"asarray",
"(",
"x",
")",
"# In case input is just pure list",
"y",
"=",
"np",
".",
"asarray",
"(",
"y",
")",
"i",
"=",
"np",
".",
"where",
"(",
"y",
"<",
"0",
")",
"n_neg",
"=",
"len",
"(",
"i",
"[",
"0",
"]",
")",
"if",
"n_neg",
">",
"0",
":",
"old_x",
"=",
"x",
"[",
"i",
"]",
"old_y",
"=",
"y",
"[",
"i",
"]",
"y",
"[",
"i",
"]",
"=",
"0",
"if",
"old_y",
"is",
"not",
"None",
":",
"warn_str",
"=",
"(",
"'{0} bin(s) contained negative flux or throughput'",
"'; it/they will be set to zero.'",
".",
"format",
"(",
"n_neg",
")",
")",
"warn_str",
"+=",
"'\\n points: {0}\\n lookup_table: {1}'",
".",
"format",
"(",
"old_x",
",",
"old_y",
")",
"# Extra info",
"self",
".",
"meta",
"[",
"'warnings'",
"]",
".",
"update",
"(",
"{",
"'NegativeFlux'",
":",
"warn_str",
"}",
")",
"warnings",
".",
"warn",
"(",
"warn_str",
",",
"AstropyUserWarning",
")",
"return",
"y"
] |
Remove negative flux.
|
[
"Remove",
"negative",
"flux",
"."
] |
train
|
https://github.com/spacetelescope/synphot_refactor/blob/9c064f3cff0c41dd8acadc0f67c6350931275b9f/synphot/models.py#L328-L360
|
spacetelescope/synphot_refactor
|
synphot/models.py
|
Empirical1D.evaluate
|
def evaluate(self, inputs):
"""Evaluate the model.
Parameters
----------
inputs : number or ndarray
Wavelengths in same unit as ``points``.
Returns
-------
y : number or ndarray
Flux or throughput in same unit as ``lookup_table``.
"""
y = super(Empirical1D, self).evaluate(inputs)
# Assume NaN at both ends need to be extrapolated based on
# nearest end point.
if self.fill_value is np.nan:
# Cannot use sampleset() due to ExtinctionModel1D
x = np.squeeze(self.points)
if np.isscalar(y): # pragma: no cover
if inputs < x[0]:
y = self.lookup_table[0]
elif inputs > x[-1]:
y = self.lookup_table[-1]
else:
y[inputs < x[0]] = self.lookup_table[0]
y[inputs > x[-1]] = self.lookup_table[-1]
return self._process_neg_flux(inputs, y)
|
python
|
def evaluate(self, inputs):
"""Evaluate the model.
Parameters
----------
inputs : number or ndarray
Wavelengths in same unit as ``points``.
Returns
-------
y : number or ndarray
Flux or throughput in same unit as ``lookup_table``.
"""
y = super(Empirical1D, self).evaluate(inputs)
# Assume NaN at both ends need to be extrapolated based on
# nearest end point.
if self.fill_value is np.nan:
# Cannot use sampleset() due to ExtinctionModel1D
x = np.squeeze(self.points)
if np.isscalar(y): # pragma: no cover
if inputs < x[0]:
y = self.lookup_table[0]
elif inputs > x[-1]:
y = self.lookup_table[-1]
else:
y[inputs < x[0]] = self.lookup_table[0]
y[inputs > x[-1]] = self.lookup_table[-1]
return self._process_neg_flux(inputs, y)
|
[
"def",
"evaluate",
"(",
"self",
",",
"inputs",
")",
":",
"y",
"=",
"super",
"(",
"Empirical1D",
",",
"self",
")",
".",
"evaluate",
"(",
"inputs",
")",
"# Assume NaN at both ends need to be extrapolated based on",
"# nearest end point.",
"if",
"self",
".",
"fill_value",
"is",
"np",
".",
"nan",
":",
"# Cannot use sampleset() due to ExtinctionModel1D",
"x",
"=",
"np",
".",
"squeeze",
"(",
"self",
".",
"points",
")",
"if",
"np",
".",
"isscalar",
"(",
"y",
")",
":",
"# pragma: no cover",
"if",
"inputs",
"<",
"x",
"[",
"0",
"]",
":",
"y",
"=",
"self",
".",
"lookup_table",
"[",
"0",
"]",
"elif",
"inputs",
">",
"x",
"[",
"-",
"1",
"]",
":",
"y",
"=",
"self",
".",
"lookup_table",
"[",
"-",
"1",
"]",
"else",
":",
"y",
"[",
"inputs",
"<",
"x",
"[",
"0",
"]",
"]",
"=",
"self",
".",
"lookup_table",
"[",
"0",
"]",
"y",
"[",
"inputs",
">",
"x",
"[",
"-",
"1",
"]",
"]",
"=",
"self",
".",
"lookup_table",
"[",
"-",
"1",
"]",
"return",
"self",
".",
"_process_neg_flux",
"(",
"inputs",
",",
"y",
")"
] |
Evaluate the model.
Parameters
----------
inputs : number or ndarray
Wavelengths in same unit as ``points``.
Returns
-------
y : number or ndarray
Flux or throughput in same unit as ``lookup_table``.
|
[
"Evaluate",
"the",
"model",
"."
] |
train
|
https://github.com/spacetelescope/synphot_refactor/blob/9c064f3cff0c41dd8acadc0f67c6350931275b9f/synphot/models.py#L370-L401
|
spacetelescope/synphot_refactor
|
synphot/models.py
|
GaussianAbsorption1D.evaluate
|
def evaluate(x, amplitude, mean, stddev):
"""
GaussianAbsorption1D model function.
"""
return 1.0 - Gaussian1D.evaluate(x, amplitude, mean, stddev)
|
python
|
def evaluate(x, amplitude, mean, stddev):
"""
GaussianAbsorption1D model function.
"""
return 1.0 - Gaussian1D.evaluate(x, amplitude, mean, stddev)
|
[
"def",
"evaluate",
"(",
"x",
",",
"amplitude",
",",
"mean",
",",
"stddev",
")",
":",
"return",
"1.0",
"-",
"Gaussian1D",
".",
"evaluate",
"(",
"x",
",",
"amplitude",
",",
"mean",
",",
"stddev",
")"
] |
GaussianAbsorption1D model function.
|
[
"GaussianAbsorption1D",
"model",
"function",
"."
] |
train
|
https://github.com/spacetelescope/synphot_refactor/blob/9c064f3cff0c41dd8acadc0f67c6350931275b9f/synphot/models.py#L452-L456
|
spacetelescope/synphot_refactor
|
synphot/models.py
|
GaussianAbsorption1D.fit_deriv
|
def fit_deriv(x, amplitude, mean, stddev):
"""
GaussianAbsorption1D model function derivatives.
"""
import operator
return list(map(
operator.neg, Gaussian1D.fit_deriv(x, amplitude, mean, stddev)))
|
python
|
def fit_deriv(x, amplitude, mean, stddev):
"""
GaussianAbsorption1D model function derivatives.
"""
import operator
return list(map(
operator.neg, Gaussian1D.fit_deriv(x, amplitude, mean, stddev)))
|
[
"def",
"fit_deriv",
"(",
"x",
",",
"amplitude",
",",
"mean",
",",
"stddev",
")",
":",
"import",
"operator",
"return",
"list",
"(",
"map",
"(",
"operator",
".",
"neg",
",",
"Gaussian1D",
".",
"fit_deriv",
"(",
"x",
",",
"amplitude",
",",
"mean",
",",
"stddev",
")",
")",
")"
] |
GaussianAbsorption1D model function derivatives.
|
[
"GaussianAbsorption1D",
"model",
"function",
"derivatives",
"."
] |
train
|
https://github.com/spacetelescope/synphot_refactor/blob/9c064f3cff0c41dd8acadc0f67c6350931275b9f/synphot/models.py#L459-L465
|
spacetelescope/synphot_refactor
|
synphot/models.py
|
Lorentz1D.sampleset
|
def sampleset(self, factor_step=0.05, **kwargs):
"""Return ``x`` array that samples the feature.
Parameters
----------
factor_step : float
Factor for sample step calculation. The step is calculated
using ``factor_step * self.fwhm``.
kwargs : dict
Keyword(s) for ``bounding_box`` calculation.
"""
w1, w2 = self.bounding_box(**kwargs)
dw = factor_step * self.fwhm
if self._n_models == 1:
w = np.arange(w1, w2, dw)
else:
w = list(map(np.arange, w1, w2, dw))
return np.asarray(w)
|
python
|
def sampleset(self, factor_step=0.05, **kwargs):
"""Return ``x`` array that samples the feature.
Parameters
----------
factor_step : float
Factor for sample step calculation. The step is calculated
using ``factor_step * self.fwhm``.
kwargs : dict
Keyword(s) for ``bounding_box`` calculation.
"""
w1, w2 = self.bounding_box(**kwargs)
dw = factor_step * self.fwhm
if self._n_models == 1:
w = np.arange(w1, w2, dw)
else:
w = list(map(np.arange, w1, w2, dw))
return np.asarray(w)
|
[
"def",
"sampleset",
"(",
"self",
",",
"factor_step",
"=",
"0.05",
",",
"*",
"*",
"kwargs",
")",
":",
"w1",
",",
"w2",
"=",
"self",
".",
"bounding_box",
"(",
"*",
"*",
"kwargs",
")",
"dw",
"=",
"factor_step",
"*",
"self",
".",
"fwhm",
"if",
"self",
".",
"_n_models",
"==",
"1",
":",
"w",
"=",
"np",
".",
"arange",
"(",
"w1",
",",
"w2",
",",
"dw",
")",
"else",
":",
"w",
"=",
"list",
"(",
"map",
"(",
"np",
".",
"arange",
",",
"w1",
",",
"w2",
",",
"dw",
")",
")",
"return",
"np",
".",
"asarray",
"(",
"w",
")"
] |
Return ``x`` array that samples the feature.
Parameters
----------
factor_step : float
Factor for sample step calculation. The step is calculated
using ``factor_step * self.fwhm``.
kwargs : dict
Keyword(s) for ``bounding_box`` calculation.
|
[
"Return",
"x",
"array",
"that",
"samples",
"the",
"feature",
"."
] |
train
|
https://github.com/spacetelescope/synphot_refactor/blob/9c064f3cff0c41dd8acadc0f67c6350931275b9f/synphot/models.py#L530-L551
|
spacetelescope/synphot_refactor
|
synphot/models.py
|
PowerLawFlux1D.evaluate
|
def evaluate(self, x, *args):
"""Return flux in PHOTLAM. Assume input wavelength is in Angstrom."""
xx = x / self.x_0
y = (self.amplitude * xx ** (-self.alpha)) * self._flux_unit
flux = units.convert_flux(x, y, units.PHOTLAM)
return flux.value
|
python
|
def evaluate(self, x, *args):
"""Return flux in PHOTLAM. Assume input wavelength is in Angstrom."""
xx = x / self.x_0
y = (self.amplitude * xx ** (-self.alpha)) * self._flux_unit
flux = units.convert_flux(x, y, units.PHOTLAM)
return flux.value
|
[
"def",
"evaluate",
"(",
"self",
",",
"x",
",",
"*",
"args",
")",
":",
"xx",
"=",
"x",
"/",
"self",
".",
"x_0",
"y",
"=",
"(",
"self",
".",
"amplitude",
"*",
"xx",
"**",
"(",
"-",
"self",
".",
"alpha",
")",
")",
"*",
"self",
".",
"_flux_unit",
"flux",
"=",
"units",
".",
"convert_flux",
"(",
"x",
",",
"y",
",",
"units",
".",
"PHOTLAM",
")",
"return",
"flux",
".",
"value"
] |
Return flux in PHOTLAM. Assume input wavelength is in Angstrom.
|
[
"Return",
"flux",
"in",
"PHOTLAM",
".",
"Assume",
"input",
"wavelength",
"is",
"in",
"Angstrom",
"."
] |
train
|
https://github.com/spacetelescope/synphot_refactor/blob/9c064f3cff0c41dd8acadc0f67c6350931275b9f/synphot/models.py#L624-L629
|
spacetelescope/synphot_refactor
|
synphot/models.py
|
Trapezoid1D.sampleset
|
def sampleset(self):
"""Return ``x`` array that samples the feature."""
x1, x4 = self.bounding_box
dw = self.width * 0.5
x2 = self.x_0 - dw
x3 = self.x_0 + dw
if self._n_models == 1:
w = [x1, x2, x3, x4]
else:
w = list(zip(x1, x2, x3, x4))
return np.asarray(w)
|
python
|
def sampleset(self):
"""Return ``x`` array that samples the feature."""
x1, x4 = self.bounding_box
dw = self.width * 0.5
x2 = self.x_0 - dw
x3 = self.x_0 + dw
if self._n_models == 1:
w = [x1, x2, x3, x4]
else:
w = list(zip(x1, x2, x3, x4))
return np.asarray(w)
|
[
"def",
"sampleset",
"(",
"self",
")",
":",
"x1",
",",
"x4",
"=",
"self",
".",
"bounding_box",
"dw",
"=",
"self",
".",
"width",
"*",
"0.5",
"x2",
"=",
"self",
".",
"x_0",
"-",
"dw",
"x3",
"=",
"self",
".",
"x_0",
"+",
"dw",
"if",
"self",
".",
"_n_models",
"==",
"1",
":",
"w",
"=",
"[",
"x1",
",",
"x2",
",",
"x3",
",",
"x4",
"]",
"else",
":",
"w",
"=",
"list",
"(",
"zip",
"(",
"x1",
",",
"x2",
",",
"x3",
",",
"x4",
")",
")",
"return",
"np",
".",
"asarray",
"(",
"w",
")"
] |
Return ``x`` array that samples the feature.
|
[
"Return",
"x",
"array",
"that",
"samples",
"the",
"feature",
"."
] |
train
|
https://github.com/spacetelescope/synphot_refactor/blob/9c064f3cff0c41dd8acadc0f67c6350931275b9f/synphot/models.py#L637-L649
|
awesto/djangoshop-stripe
|
shop_stripe/payment.py
|
StripePayment.get_payment_request
|
def get_payment_request(self, cart, request):
"""
From the given request, add a snippet to the page.
"""
try:
self.charge(cart, request)
thank_you_url = OrderModel.objects.get_latest_url()
js_expression = 'window.location.href="{}";'.format(thank_you_url)
return js_expression
except (KeyError, stripe.error.StripeError) as err:
raise ValidationError(err)
|
python
|
def get_payment_request(self, cart, request):
"""
From the given request, add a snippet to the page.
"""
try:
self.charge(cart, request)
thank_you_url = OrderModel.objects.get_latest_url()
js_expression = 'window.location.href="{}";'.format(thank_you_url)
return js_expression
except (KeyError, stripe.error.StripeError) as err:
raise ValidationError(err)
|
[
"def",
"get_payment_request",
"(",
"self",
",",
"cart",
",",
"request",
")",
":",
"try",
":",
"self",
".",
"charge",
"(",
"cart",
",",
"request",
")",
"thank_you_url",
"=",
"OrderModel",
".",
"objects",
".",
"get_latest_url",
"(",
")",
"js_expression",
"=",
"'window.location.href=\"{}\";'",
".",
"format",
"(",
"thank_you_url",
")",
"return",
"js_expression",
"except",
"(",
"KeyError",
",",
"stripe",
".",
"error",
".",
"StripeError",
")",
"as",
"err",
":",
"raise",
"ValidationError",
"(",
"err",
")"
] |
From the given request, add a snippet to the page.
|
[
"From",
"the",
"given",
"request",
"add",
"a",
"snippet",
"to",
"the",
"page",
"."
] |
train
|
https://github.com/awesto/djangoshop-stripe/blob/010d4642f971961cfeb415520ad819b3751281cb/shop_stripe/payment.py#L28-L38
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.