### Install svo_filters from GitHub

Source: https://github.com/hover2pi/svo_filters/blob/master/docs/_build/html/_sources/README.rst.txt

Installs the svo_filters package by cloning the GitHub repository and running the setup script. This is useful for developers or those who want the latest version.

```bash
git clone https://github.com/hover2pi/svo_filters.git
python svo_filters/setup.py install
```

--------------------------------

### Install svo_filters Package

Source: https://github.com/hover2pi/svo_filters/blob/master/svo_demo.ipynb

Provides instructions for installing the svo_filters package using pip or by cloning the GitHub repository and running the setup script. This makes the package available for import in Python projects.

```bash
pip install svo_filters
```

```bash
git clone https://github.com/hover2pi/svo_filters.git
cd svo_filters
python setup.py install
```

--------------------------------

### Install svo_filters using pip

Source: https://github.com/hover2pi/svo_filters/blob/master/docs/_build/html/_sources/README.rst.txt

Installs the svo_filters package using the pip package manager. This is the recommended method for most users.

```bash
pip install svo_filters
```

--------------------------------

### Install svo_filters package via pip or source

Source: https://github.com/hover2pi/svo_filters/blob/master/docs/index.rst

Installs the svo_filters Python package using pip or by cloning the repository. The pip command fetches the package from PyPI, while the git clone method retrieves the source code. No additional dependencies beyond standard Python packaging are required.

```bash
pip install svo_filters

git clone https://github.com/hover2pi/svo_filters.git
python svo_filters/setup.py install
```

--------------------------------

### List Available Filters in Python

Source: https://context7.com/hover2pi/svo_filters/llms.txt

This code lists all locally available photometric filters using the svo_filters package. It depends on the svo_filters library being installed and requires no inputs beyond loading the module. The output is a list of filter names, and it is limited to locally stored XML files.

```python
from svo_filters import svo

# Get a list of all available filters
available = svo.filters()
print(available[:10])
# Output: ['2MASS.H', '2MASS.J', '2MASS.Ks', 'ACS_HRC.F435W', 'ACS_HRC.F555W', ...]
```

--------------------------------

### Get filter bin centers (Python)

Source: https://github.com/hover2pi/svo_filters/blob/master/docs/_build/html/_modules/svo.html

Provides a property that returns the central wavelengths and average throughput for each bin. Utilizes NumPy to compute means across the bin dimension.

```Python
@property
    def centers(self):
        """A getter for the wavelength bin centers and average fluxes"""
        # Get the bin centers
        w_cen = np.nanmean(self.wave.value, axis=1)
        f_cen = np.nanmean(self.throughput, axis=1)

        return np.asarray([w_cen, f_cen])
```

--------------------------------

### Set and get filter flux units (Python)

Source: https://github.com/hover2pi/svo_filters/blob/master/docs/_build/html/_modules/svo.html

Implements a getter and setter for the filter's flux units, validating input types and performing unit conversion when necessary. Updates the zero‑point flux accordingly.

```Python
@property
    def flux_units(self):
        """A getter for the flux units"""
        return self._flux_units

    @flux_units.setter
    def flux_units(self, units):
        """
        A setter for the flux units

        Parameters
        ----------
        units: str, astropy.units.core.PrefixUnit
            The desired units of the zeropoint flux density
        """
        # Check that the units are valid
        dtypes = (q.core.PrefixUnit, q.quantity.Quantity, q.core.CompositeUnit)
        if not isinstance(units, dtypes):
            raise ValueError(units, "units not understood.")

        # Check that the units changed
        if units != self.flux_units:

            # Convert to new units
            sfd = q.spectral_density(self.wave_eff)
            self.zp = self.zp.to(units, equivalencies=sfd)

            # Store new units
            self._flux_units = units
```

--------------------------------

### Get Filter Wavelength Data

Source: https://github.com/hover2pi/svo_filters/blob/master/docs/_build/html/_modules/svo_filters/svo.html

The `wave` property serves as a getter for the filter's wavelength data, returning the internal `_wave` attribute. The setter validates that the input wavelength is an `astropy.units.quantity.Quantity` to ensure correct unit handling.

```python
@property
def wave(self):
        """A getter for the wavelength"""
        return self._wave

    @wave.setter
def wave(self, wavelength):
        """A setter for the wavelength

        Parameters
        ----------
        wavelength: astropy.units.quantity.Quantity
            The array with units
        """
        # Test units
        if not isinstance(wavelength, q.quantity.Quantity):
            raise ValueError("Wavelength must be in length units.")

        self._wave = wavelength
        self.wave_units = wavelength.unit
```

--------------------------------

### Get Relative Spectral Response Shape (Python)

Source: https://github.com/hover2pi/svo_filters/blob/master/svo_demo.ipynb

Retrieves the shape of the relative spectral response (RSR) array for a loaded photometric filter. The RSR is stored as a 2D array of wavelength and throughput values.

```python
H_band.rsr.shape
```

--------------------------------

### Manage Filter Wavelength Units

Source: https://github.com/hover2pi/svo_filters/blob/master/docs/_build/html/_modules/svo_filters/svo.html

The `wave_units` property allows getting and setting the wavelength units for the filter. The setter ensures that the provided units are equivalent to meters (i.e., length units) and updates all relevant wavelength-related attributes to the new units, rounding them to 5 decimal places.

```python
@property
def wave_units(self):
        """A getter for the wavelength units"""
        return self._wave_units

    @wave_units.setter
def wave_units(self, units):
        """
        A setter for the wavelength units

        Parameters
        ----------
        units: str, astropy.units.core.PrefixUnit
            The wavelength units
        """
        # Make sure it's length units
        if not units.is_equivalent(q.m):
            raise ValueError(units, ": New wavelength units must be a length.")

        # Update the units
        self._wave_units = units

        # Update all the wavelength values
        self._wave = self.wave.to(self.wave_units).round(5)
        self.wave_min = self.wave_min.to(self.wave_units).round(5)
        self.wave_max = self.wave_max.to(self.wave_units).round(5)
        self.wave_eff = self.wave_eff.to(self.wave_units).round(5)
        self.wave_center = self.wave_center.to(self.wave_units).round(5)
        self.wave_mean = self.wave_mean.to(self.wave_units).round(5)
        self.wave_peak = self.wave_peak.to(self.wave_units).round(5)
        self.wave_phot = self.wave_phot.to(self.wave_units).round(5)
        self.wave_pivot = self.wave_pivot.to(self.wave_units).round(5)
        self.width_eff = self.width_eff.to(self.wave_units).round(5)
        self.fwhm = self.fwhm.to(self.wave_units).round(5)
```

--------------------------------

### Get Relative Spectral Response (RSR)

Source: https://github.com/hover2pi/svo_filters/blob/master/docs/_build/html/_modules/svo_filters/svo.html

The `rsr` property provides the relative spectral response curve of the filter. It returns a NumPy array where the first column is wavelength and the second is the throughput. This is derived from the filter's wavelength and throughput data.

```python
@property
def rsr(self):
        """A getter for the relative spectral response (rsr) curve"""
        arr = np.array([self.wave.value, self.throughput]).swapaxes(0, 1)

        return arr
```

--------------------------------

### Load and Process SVO Filter Files

Source: https://github.com/hover2pi/svo_filters/blob/master/docs/_build/html/_modules/svo.html

Loads SVO filter profiles from XML or TXT files, sets wavelength and throughput, and renames attributes for easier access. It handles unit conversions for wavelength and flux, and retrieves calibration references and extinction vectors.

```python
err = """No filters match {}\n\nCurrent filters: {}\n\nA full list of available filters from the\nSVO Filter Profile Service can be found at\nhttp: //svo2.cab.inta-csic.es/theory/fps3/\n\nPlace the desired filter XML file in your\nfilter directory and try again."""

raise IOError(err)

# Get the first line to determine format
with open(filepath) as f:
    top = f.readline()

# Read in XML file
if top.startswith('<?xml'):
    self.load_xml(filepath)

# Read in txt file
elif filepath.endswith('.txt'):
    self.load_txt(filepath)

else:
    raise TypeError("File must be XML or ascii format.")

# Set the wavelength and throughput
self._wave_units = q.AA
self._wave = np.array([self.raw[0]]) * self.wave_units
self._throughput = np.array([self.raw[1]])

# Set n_bins and pixels_per_bin
self.n_bins = 1
self.pixels_per_bin = self.raw.shape[-1]

# Rename some values and apply units
self.wave_min = self.WavelengthMin * self.wave_units
self.wave_max = self.WavelengthMax * self.wave_units
self.wave_eff = self.WavelengthEff * self.wave_units
self.wave_center = self.WavelengthCen * self.wave_units
self.wave_mean = self.WavelengthMean * self.wave_units
self.wave_peak = self.WavelengthPeak * self.wave_units
self.wave_phot = self.WavelengthPhot * self.wave_units
self.wave_pivot = self.WavelengthPivot * self.wave_units
self.width_eff = self.WidthEff * self.wave_units
self.fwhm = self.FWHM * self.wave_units
self.zp = self.ZeroPoint * q.Unit(self.ZeroPointUnit)

# Delete redundant attributes
del self.WavelengthMin, self.WavelengthMax, self.WavelengthEff
del self.WavelengthCen, self.WavelengthMean, self.WavelengthPeak
del self.WavelengthPhot, self.WavelengthPivot, self.WidthEff, self.FWHM
del self.ZeroPointUnit, self.ZeroPoint
try:
    del self.WavelengthUnit
except AttributeError:
    pass

# Set the wavelength units
if wave_units is not None:
    self.wave_units = wave_units

# Set zeropoint flux units
if flux_units is not None:
    self._flux_units = self.zp.unit
    self.flux_units = flux_units

# Get references
self.refs = []
try:
    if isinstance(self.CalibrationReference, str):
        self.refs = [self.CalibrationReference.split('=')[-1]]
except:
    self.CalibrationReference = None

# Set a base name
self.name = self.filterID.split('/')[-1]

# Try to get the extinction vector R from Green et al. (2018)
self.ext_vector = EXTINCTION.get(self.name, 0)

# Bin
if kwargs:
    bwargs = {k: v for k, v in kwargs.items() if k in inspect.signature(self.bin).parameters.keys()}
    self.bin(**bwargs)
```

--------------------------------

### Enable Sphinx Navigation Theme

Source: https://github.com/hover2pi/svo_filters/blob/master/docs/_build/html/_modules/svo_filters/svo.html

Initializes the Sphinx Read the Docs theme navigation. This snippet enables the theme's navigation features using jQuery. It depends on the Sphinx documentation framework and the Read the Docs theme. No input is required, and it outputs an enabled navigation interface.

```JavaScript
jQuery(function () { SphinxRtdTheme.Navigation.enable(true); });
```

--------------------------------

### Initialize Filter Properties (Python)

Source: https://github.com/hover2pi/svo_filters/blob/master/docs/_build/html/_modules/svo_filters/svo.html

Initializes filter properties like wavelength, throughput, and metadata. It sets up a 'Top Hat' filter profile with default values and calculates effective wavelength and width based on input parameters. Dependencies include numpy and quantities.

```python
def __init__(self, pixels_per_bin, wave_min, wave_max, pixels_per_bin):
        """The number of pixels for the filter
        """
        # Get min, max, effective wavelengths and width
        self.pixels_per_bin = pixels_per_bin
        self.n_bins = 1
        self._wave_units = q.AA
        wave_min = wave_min.to(self.wave_units)
        wave_max = wave_max.to(self.wave_units)

        # Create the RSR curve
        self._wave = np.linspace(wave_min, wave_max, pixels_per_bin)
        self._throughput = np.ones_like(self.wave)
        self.raw = np.array([self.wave.value, self.throughput])

        # Calculate the effective wavelength
        wave_eff = ((wave_min + wave_max) / 2.).value
        width = (wave_max - wave_min).value

        # Add the attributes
        self.path = ''
        self.refs = ''
        self.Band = 'Top Hat'
        self.CalibrationReference = ''
        self.FWHM = width
        self.Facility = '-'
        self.FilterProfileService = '-'
        self.MagSys = '-'
        self.PhotCalID = ''
        self.PhotSystem = ''
        self.ProfileReference = ''
        self.WavelengthMin = wave_min.value
        self.WavelengthMax = wave_max.value
        self.WavelengthCen = wave_eff
        self.WavelengthEff = wave_eff
        self.WavelengthMean = wave_eff
        self.WavelengthPeak = wave_eff
        self.WavelengthPhot = wave_eff
        self.WavelengthPivot = wave_eff
        self.WavelengthUCD = ''
        self.WidthEff = width
        self.ZeroPoint = 0
        self.ZeroPointType = ''
        self.ZeroPointUnit = 'Jy'
        self.filterID = 'Top Hat'
```

--------------------------------

### Load and Bin Photometric Filter (Python)

Source: https://github.com/hover2pi/svo_filters/blob/master/svo_demo.ipynb

Loads a photometric filter (e.g., WFC3_IR.G141) and applies arbitrary binning using the 'n_bins' argument. This is useful for analyzing grism data. The filter's metadata and spectral response are then displayed.

```python
G141 = svo.Filter('WFC3_IR.G141', n_bins=15)
G141.info()
G141.plot()
```

--------------------------------

### Initialize Filter object with bandpass data

Source: https://github.com/hover2pi/svo_filters/blob/master/docs/_build/html/_modules/svo.html

Creates a Filter object to store photometric filter profile and metadata. Supports loading from filter files or creating custom top hat filters. Requires band name and optional filter directory path. Returns a Filter object with loaded bandpass data and associated metadata attributes.

```python
def __init__(self, band, filter_directory=None,
             wave_units=q.um, flux_units=q.erg/q.s/q.cm**2/q.AA,
             **kwargs):
    """
    Loads the bandpass data into the Filter object

    Parameters
    ----------
    band: str
        The bandpass filename (e.g. 2MASS.J)
    filter_directory: str
        The directory containing the filter files
    wave_units: str, astropy.units.core.PrefixUnit  (optional)
        The wavelength units
    flux_units: str, astropy.units.core.PrefixUnit  (optional)
        The zeropoint flux units
    """
    if filter_directory is None:
        filter_directory = resource_filename('svo_filters', 'data/filters/')

    # Check if TopHat
    if band.lower().replace('-', '').replace(' ', '') == 'tophat':

        # check kwargs for limits
        wave_min = kwargs.get('wave_min')
        wave_max = kwargs.get('wave_max')
        filepath = ''

        if wave_min is None or wave_max is None:
            raise ValueError("Please provide **{'wave_min', 'wave_max'} to create top hat filter.")

        else:
            # Load the filter
            n_pix = kwargs.get('n_pixels', 100)
            self.load_TopHat(wave_min, wave_max, n_pix)

    else:

        # Get list of filters
        files = glob(filter_directory+'\*')
        no_ext = {f.replace('.txt', ''): f for f in files}
        bands = [os.path.basename(b) for b in no_ext]
        fp = os.path.join(filter_directory, band)
        filepath = no_ext.get(fp, fp)

        # If the filter is missing, ask what to do
        if band not in bands:
```

--------------------------------

### Load IPython Extensions and Bokeh

Source: https://github.com/hover2pi/svo_filters/blob/master/svo_demo.ipynb

This snippet loads IPython extensions for automatic reloading and configures Bokeh for notebook output. It also imports necessary libraries like numpy and pkg_resources.

```python
%load_ext autoreload
%autoreload 2
from bokeh.io import output_notebook
import numpy as np
from pkg_resources import resource_filename
output_notebook()
```

--------------------------------

### Load Top Hat Filter

Source: https://github.com/hover2pi/svo_filters/blob/master/docs/_build/html/_modules/svo_filters/svo.html

Loads a top hat filter given wavelength min and max values. Requires parameters for minimum and maximum wavelengths and an optional number of pixels per bin.

```python
def load_TopHat(self, wave_min, wave_max, pixels_per_bin=100):
    """
    Loads a top hat filter given wavelength min and max values

    Parameters
    ----------
    wave_min: astropy.units.quantity (optional)
        The minimum wavelength to use
    wave_max: astropy.units.quantity (optional)
        The maximum wavelength to use
    n_pixels: int

```

--------------------------------

### Get Filter Throughput Data

Source: https://github.com/hover2pi/svo_filters/blob/master/docs/_build/html/_modules/svo_filters/svo.html

The `throughput` property acts as a getter for the filter's throughput values. It returns the internal `_throughput` attribute. A setter is also provided to update the throughput, which includes a shape validation to ensure consistency with the wavelength data.

```python
@property
def throughput(self):
        """A getter for the throughput"""
        return self._throughput

    @throughput.setter
def throughput(self, points):
        """A setter for the throughput

        Parameters
        ----------
        throughput: sequence
            The array of throughput points
        """
        # Test shape
        if not points.shape == self.wave.shape:
            raise ValueError("Throughput and wavelength must be same shape.")

        self._throughput = points
```

--------------------------------

### List available photometric filters

Source: https://github.com/hover2pi/svo_filters/blob/master/docs/_build/html/_sources/README.rst.txt

Lists all available photometric filters from the SVO Filter Profile Service. This function helps users discover available filters.

```python
from svo_filters import svo
svo.filters()
```

--------------------------------

### Filter Management and Catalog Generation

Source: https://github.com/hover2pi/svo_filters/blob/master/docs/_build/html/_modules/svo.html

Manages available astronomical filters by loading spectral response curves from a directory and generating a searchable catalog. Supports automatic pickle caching, multiple output formats (table/dict), and filter metadata extraction. Includes update functionality to refresh the filter database when new filters are added.

```python
def filters(filter_directory=None, update=False, fmt='table', **kwargs):
    """
    Get a list of the available filters

    Parameters
    ----------
    filter_directory: str
        The directory containing the filter relative spectral response curves
    update: bool
        Check the filter directory for new filters and generate pickle of table
    fmt: str
        The format for the returned table

    Returns
    -------
    list
        The list of band names
    """
    if filter_directory is None:
        filter_directory = resource_filename('svo_filters', 'data/filters/')

    # Get the pickle path and make sure file exists
    p_path = os.path.join(filter_directory, 'filter_list.p')
    updated = False
    if not os.path.isfile(p_path):
        os.system('touch {}'.format(p_path))

    if update:

        print('Loading filters into table...')

        # Get all the filters (except the pickle)
        files = glob(filter_directory+'*')
        files = [f for f in files if not f.endswith('.p')]
        bands = [os.path.basename(b) for b in files]
        tables = []

        for band in bands:

            # Load the filter
            filt = Filter(band, **kwargs)
            filt.Band = band

            # Put metadata into table with correct dtypes
            info = filt.info(True)
            vals = [float(i) if i.replace('.', '').replace('-', '')
                    .replace('+', '').isnumeric() else i
                    for i in info['Values']]
            dtypes = np.array([type(i) for i in vals])
            table = at.Table(np.array([vals]), names=info['Attributes'],
                             dtype=dtypes)

            tables.append(table)

            del filt, info, table

        # Write to the pickle
        with open(p_path, 'wb') as file:
            pickle.dump(at.vstack(tables), file)

    # Load the saved pickle
    data = {}
    if os.path.isfile(p_path):
        with open(p_path, 'rb') as file:
            data = pickle.load(file)

    # Return the data
    if data:

        if fmt == 'dict':
            data = {r[0]: {k: r[k].value if hasattr(r[k], 'unit') else r[k]
                    for k in data.keys()[1:]} for r in data}

        else:

            # Add Band as index
            data.add_index('Band')

        return data

    # Or try to generate it once
    else:
        if not updated:
            updated = True
            filters(update=True)
        else:
            print('No filters found in', filter_directory)
```

--------------------------------

### Load SVO Filter Profile

Source: https://github.com/hover2pi/svo_filters/blob/master/docs/_build/html/_modules/svo_filters/svo.html

Loads filter data from XML or text files based on file format detection. Supports automatic unit handling for wavelength and flux values. Reads filter properties including min/max wavelengths, effective wavelength, and zeropoint values.

```python
with open(filepath) as f:
    top = f.readline()

if top.startswith('<?xml'):
    self.load_xml(filepath)
elif filepath.endswith('.txt'):
    self.load_txt(filepath)
else:
    raise TypeError("File must be XML or ascii format.")
```

--------------------------------

### Import and Use svo_filters in Python

Source: https://github.com/hover2pi/svo_filters/blob/master/svo_demo.ipynb

Demonstrates how to import the 'svo' module from the 'svo_filters' package and how to call the 'filters()' function to display the available filter data. The output is a Bokeh table object.

```python
from svo_filters import svo

# Display available filters
svo.filters()
```

--------------------------------

### Create and inspect a photometric filter object

Source: https://github.com/hover2pi/svo_filters/blob/master/docs/_build/html/_sources/index.rst.txt

Creates a Filter object from the SVO database using a given bandpass name (e.g., '2MASS.H'). The .info() method displays metadata about the filter, such as its central wavelength and width.

```python
from svo_filters import svo
H_band = svo.Filter('2MASS.H')
H_band.info()
```

--------------------------------

### Bin Filter Method

Source: https://github.com/hover2pi/svo_filters/blob/master/docs/_build/html/_modules/svo_filters/svo.html

Breaks the filter up into bins and applies a throughput to each bin, useful for G141, G102, and other grisms. Requires parameters such as the number of bins or pixels per bin and optional wavelength limits.

```python
def bin(self, n_bins=1, pixels_per_bin=None, wave_min=None, wave_max=None):
    """
    Break the filter up into bins and apply a throughput to each bin,
    useful for G141, G102, and other grisms

    Parameters
    ----------
    n_bins: int
        The number of bins to dice the throughput curve into
    pixels_per_bin: int (optional)
        The number of channels per bin, which will be used
        to calculate n_bins
    wave_min: astropy.units.quantity (optional)
        The minimum wavelength to use
    wave_max: astropy.units.quantity (optional)
        The maximum wavelength to use
    """
    # Get wavelength limits
    if wave_min is not None:
        self.wave_min = wave_min
    if wave_max is not None:
        self.wave_max = wave_max

    # Trim the wavelength by the given min and max
    raw_wave = self.raw[0]
    whr = np.logical_and(raw_wave * q.AA >= self.wave_min,
                         raw_wave * q.AA <= self.wave_max)
    self.wave = (raw_wave[whr] * q.AA).to(self.wave_units)
    self.throughput = self.raw[1][whr]
    print('Bandpass trimmed to',
          '{} - {}'.format(self.wave_min, self.wave_max))

    # Calculate the number of bins and channels
    pts = len(self.wave)
    if isinstance(pixels_per_bin, int):
        self.pixels_per_bin = pixels_per_bin
        self.n_bins = int(pts/self.pixels_per_bin)
    elif isinstance(n_bins, int):
        self.n_bins = n_bins
        self.pixels_per_bin = int(pts/self.n_bins)
    else:
        raise ValueError("Please specify 'n_bins' OR 'pixels_per_bin' as integers.")

    print('{} bins of {} pixels each.'.format(self.n_bins,
                                              self.pixels_per_bin))

    # Trim throughput edges so that there are an integer number of bins
    new_len = self.n_bins * self.pixels_per_bin
    start = (pts - new_len) // 2
    self.wave = self.wave[start:new_len+start].reshape(self.n_bins, self.pixels_per_bin)
    self.throughput = self.throughput[start:new_len+start].reshape(self.n_bins, self.pixels_per_bin)
```

--------------------------------

### Load a grism filter with custom binning

Source: https://github.com/hover2pi/svo_filters/blob/master/docs/index.rst

Instantiates a grism filter (WFC3_IR.G141) with a specified number of wavelength bins using the `n_bins` argument. This allows finer control over the spectral resolution for subsequent analysis. The filter can be plotted similarly to other filters.

```python
from svo_filters import svo
G141 = svo.Filter('WFC3_IR.G141', n_bins=15)
G141.plot()
```

--------------------------------

### Applying Multiple Filters to a Spectrum in Python

Source: https://context7.com/hover2pi/svo_filters/llms.txt

This snippet creates a sample spectrum and applies multiple filters to compute photometry, storing results in a dictionary. It relies on svo_filters, NumPy, and Astropy units for handling wavelength and flux arrays. Inputs: Wavelength and flux arrays with units. Outputs: Dictionary of mean fluxes, effective wavelengths, and bandwidths per filter, with print statements. Limitations: Assumes uniform flux for demo; error handling for apply() is not shown.

```python
import numpy as np
import astropy.units as q
from svo_filters import svo

# Create input spectrum
wavelength = np.linspace(0.5, 2.5, 2000) * q.um
flux = np.ones(2000) * q.erg/q.s/q.cm**2/q.AA
spectrum = [wavelength, flux]

# Load multiple SDSS filters
filter_names = ['SDSS.u', 'SDSS.g', 'SDSS.r', 'SDSS.i', 'SDSS.z']
photometry = {}

for fname in filter_names:
    filt = svo.Filter(fname)
    filtered_flux, filtered_err = filt.apply(spectrum)
    photometry[fname] = {
        'flux': filtered_flux.mean(),
        'wavelength': filt.wave_eff,
        'bandwidth': filt.fwhm
    }

# Result: dictionary of photometric measurements per filter
for name, data in photometry.items():
    print(f"{name}: λ_eff={data['wavelength']:.3f}, flux={data['flux']:.2e}")
```

--------------------------------

### Load and Inspect Photometric Filter Metadata (Python)

Source: https://github.com/hover2pi/svo_filters/blob/master/svo_demo.ipynb

Loads a specified photometric filter (e.g., 2MASS.H) using the Filter class and displays its metadata. It also generates a plot of the filter's spectral response.

```python
H_band = svo.Filter('2MASS.H')
H_band.info()
H_band.plot()
```

--------------------------------

### Create a binned Grism filter

Source: https://github.com/hover2pi/svo_filters/blob/master/docs/_build/html/_sources/README.rst.txt

Creates a Filter object for a grism, allowing for custom binning of its wavelength response. This is useful for simulating observations with grism instruments.

```python
from svo_filters import svo
G141 = svo.Filter('WFC3_IR.G141', n_bins=15)
```

--------------------------------

### Load top‑hat filter (Python)

Source: https://github.com/hover2pi/svo_filters/blob/master/docs/_build/html/_modules/svo.html

Defines a method to create a top‑hat filter given minimum and maximum wavelength bounds and an optional pixel count per bin. The implementation details are omitted in the source snippet.

```Python
def load_TopHat(self, wave_min, wave_max, pixels_per_bin=100):
        """
        Loads a top hat filter given wavelength min and max values

        Parameters
        ----------
        wave_min: astropy.units.quantity (optional)
            The minimum wavelength to use
        wave_max: astropy.units.quantity (optional)
            The maximum wavelength to use
        n_pixels: int
        """
        # Implementation not shown
```

--------------------------------

### Initialize Filter object in Python

Source: https://github.com/hover2pi/svo_filters/blob/master/docs/_build/html/_modules/svo_filters/svo.html

Creates a Filter object to store photometric filter profile data and metadata. The object can be initialized with a bandpass filename and optional parameters like filter directory and units.

```Python
class Filter:
    """
    Creates a Filter object to store a photometric filter profile
    and metadata

    Attributes
    ----------
    path: str
        The absolute filepath for the bandpass data, an ASCII file with
        a wavelength column in Angstroms and a response column of values
        ranging from 0 to 1
    refs: list, str
        The references for the bandpass data
    rsr: np.ndarray
        The wavelength and relative spectral response (RSR) arrays
    Band: str
        The band name
    CalibrationReference: str
        The paper detailing the calibration
    FWHM: float
        The FWHM for the filter
    Facility: str
        The telescope facility
    FilterProfileService: str
        The SVO source
    MagSys: str
        The magnitude system
    PhotCalID: str
        The calibration standard
    PhotSystem: str
        The photometric system
    ProfileReference: str
        The SVO reference
    WavelengthCen: float
        The center wavelength
    WavelengthEff: float
        The effective wavelength
    WavelengthMax: float
        The maximum wavelength
    WavelengthMean: float
        The mean wavelength
    WavelengthMin: float
        The minimum wavelength
    WavelengthPeak: float
        The peak wavelength
    WavelengthPhot: float
        The photon distribution based effective wavelength
    WavelengthPivot: float
        The wavelength pivot
    WavelengthUCD: str
        The SVO wavelength unit
    WavelengthUnit: str
        The wavelength unit
    WidthEff: float
        The effective width
    ZeroPoint: float
        The value of the zero point flux
    ZeroPointType: str
        The system of the zero point
    ZeroPointUnit: str
        The units of the zero point
    filterID: str
        The SVO filter ID

    """
    def __init__(self, band, filter_directory=None,
                 wave_units=q.um, flux_units=q.erg/q.s/q.cm**2/q.AA,
                 **kwargs):
        """
        Loads the bandpass data into the Filter object

        Parameters
        ----------
        band: str
            The bandpass filename (e.g. 2MASS.J)
        filter_directory: str
            The directory containing the filter files
        wave_units: str, astropy.units.core.PrefixUnit  (optional)
            The wavelength units
        flux_units: str, astropy.units.core.PrefixUnit  (optional)
            The zeropoint flux units
        """
        if filter_directory is None:
            filter_directory = resource_filename('svo_filters', 'data/filters/')

        # Check if TopHat
        if band.lower().replace('-', '').replace(' ', '') == 'tophat':

            # check kwargs for limits
            wave_min = kwargs.get('wave_min')
            wave_max = kwargs.get('wave_max')
            filepath = ''

            if wave_min is None or wave_max is None:
                raise ValueError("Please provide **{'wave_min', 'wave_max'} to create top hat filter.")

            else:
                # Load the filter
                n_pix = kwargs.get('n_pixels', 100)
                self.load_TopHat(wave_min, wave_max, n_pix)

        else:

            # Get list of filters
            files = glob(filter_directory+'*')
            no_ext = {f.replace('.txt', ''): f for f in files}
            bands = [os.path.basename(b) for b in no_ext]
            fp = os.path.join(filter_directory, band)
            filepath = no_ext.get(fp, fp)

            # If the filter is missing, ask what to do
            if band not in bands:
```

--------------------------------

### Create filter object in Python

Source: https://github.com/hover2pi/svo_filters/blob/master/docs/_build/html/index.html

Instantiates a filter object for the specified bandpass (e.g., 2MASS.H). The object contains metadata and transmission data for the filter.

```python
H_band = svo.Filter('2MASS.H')
```

--------------------------------

### Apply WFC3_IR.G141 Filter to Spectrum in Python

Source: https://github.com/hover2pi/svo_filters/blob/master/svo_demo.ipynb

This Python code snippet shows how to load the WFC3_IR.G141 filter using the svo library, load a spectrum from a file, trim the spectrum to the filter's wavelength range, and apply the filter. It requires the 'svo_filters' and 'numpy' libraries. The `apply` method can optionally generate a plot.

```python
import svo
import numpy as np
from pkg_resources import resource_filename

# Get the filter object
G141 = svo.Filter('WFC3_IR.G141', n_bins=15)

# Get a spectrum
file = resource_filename('svo_filters', 'data/spectra/vega.txt')
spec = np.genfromtxt(file, unpack=True)
spec = [i[(spec[0] > 0.9) & (spec[0] < 1.9)] for i in spec]

# Applyt the filter
filtered = G141.apply(spec, plot=True)
```

--------------------------------

### Filter Info Display

Source: https://github.com/hover2pi/svo_filters/blob/master/docs/_build/html/_modules/svo_filters/svo.html

Prints a table of information about the current filter. Optionally returns the table if fetch is set to True.

```python
def info(self, fetch=False):
    """
    Print a table of info about the current filter
    """
    # Get the info from the class
    tp = (int, bytes, bool, str, float, tuple, list, np.ndarray)
    info = [[k, str(v)] for k, v in vars(self).items() if isinstance(v, tp)
            and k not in ['rsr', 'raw', 'centers'] and not k.startswith('_')]

    # Make the table
    table = at.Table(np.asarray(info).reshape(len(info), 2),
                     names=['Attributes', 'Values'])

    # Sort and print
    table.sort('Attributes')

    if fetch:
        return table
    else:
        table.pprint(max_width=-1, max_lines=-1, align=['>', '<'])
```

--------------------------------

### Accessing Photometric Filter Properties in Python

Source: https://context7.com/hover2pi/svo_filters/llms.txt

This snippet demonstrates printing key properties of a loaded filter object, such as width, calibration, and metadata. It assumes a filter instance like i_band is already loaded using svo.Filter. Dependencies include the svo_filters package. Outputs are console prints of filter attributes; no specific inputs beyond the filter object. Limitations: Requires prior filter loading and may not handle missing attributes gracefully.

```python
print(f"FWHM: {i_band.fwhm}")  # Full width at half maximum
print(f"Effective width: {i_band.width_eff}")  # Integral(T)/max(T)

# Calibration
print(f"Zero point: {i_band.zp}")  # Vega zero point flux
print(f"Magnitude system: {i_band.MagSys}")  # Vega, AB, ST
print(f"Extinction coefficient: {i_band.ext_vector}")  # R_λ from Green+2018

# Telescope metadata
print(f"Facility: {i_band.Facility}")  # SLOAN
print(f"Instrument: {getattr(i_band, 'Instrument', 'N/A')}")  # If available
```

--------------------------------

### Create a Filter object

Source: https://github.com/hover2pi/svo_filters/blob/master/docs/_build/html/_sources/README.rst.txt

Creates a Filter object representing a specific photometric filter by passing its bandpass name. This object can then be used for further analysis.

```python
from svo_filters import svo
H_band = svo.Filter('2MASS.H')
```

--------------------------------

### Initialize Top Hat Filter in Python svo_filters

Source: https://github.com/hover2pi/svo_filters/blob/master/docs/_build/html/_modules/svo.html

This code initializes a top-hat filter with specified wavelength range and pixel count. It creates a rectangular response curve and calculates various wavelength properties including effective wavelength, FWHM, and zero point. The method sets multiple metadata attributes required for filter characterization in astronomical photometry.

```python
# Get min, max, effective wavelengths and width
self.pixels_per_bin = pixels_per_bin
self.n_bins = 1
self._wave_units = q.AA
wave_min = wave_min.to(self.wave_units)
wave_max = wave_max.to(self.wave_units)

# Create the RSR curve
self._wave = np.linspace(wave_min, wave_max, pixels_per_bin)
self._throughput = np.ones_like(self.wave)
self.raw = np.array([self.wave.value, self.throughput])

# Calculate the effective wavelength
wave_eff = ((wave_min + wave_max) / 2.).value
width = (wave_max - wave_min).value

# Add the attributes
self.path = ''
self.refs = ''
self.Band = 'Top Hat'
self.CalibrationReference = ''
self.FWHM = width
self.Facility = '-'
self.FilterProfileService = '-'
self.MagSys = '-'
self.PhotCalID = ''
self.PhotSystem = ''
self.ProfileReference = ''
self.WavelengthMin = wave_min.value
self.WavelengthMax = wave_max.value
self.WavelengthCen = wave_eff
self.WavelengthEff = wave_eff
self.WavelengthMean = wave_eff
self.WavelengthPeak = wave_eff
self.WavelengthPhot = wave_eff
self.WavelengthPivot = wave_eff
self.WavelengthUCD = ''
self.WidthEff = width
self.ZeroPoint = 0
self.ZeroPointType = ''
self.ZeroPointUnit = 'Jy'
self.filterID = 'Top Hat'
```

--------------------------------

### Load Filter Data from Text File in Python

Source: https://github.com/hover2pi/svo_filters/blob/master/docs/_build/html/_modules/svo.html

This method loads filter transmission data from a text file and calculates photometric properties. It converts wavelength units from microns to Angstroms when needed, computes the zero point using a Vega spectrum reference, and derives wavelength characteristics through numerical integration. The function assumes the file contains two columns: wavelength and throughput values.

```python
def load_txt(self, filepath):
    """Load the filter from a txt file

    Parameters
    ----------
    file: str
        The filepath
    """
    self.raw = np.genfromtxt(filepath, unpack=True)

    # Convert to Angstroms if microns
    if self.raw[0][-1] < 100:
        self.raw[0] = self.raw[0] * 10000

    self.WavelengthUnit = str(q.AA)
    self.ZeroPointUnit = str(q.erg/q.s/q.cm**2/q.AA)
    x, f = self.raw

    # Get a spectrum of Vega
    vega_file = resource_filename('svo_filters', 'data/spectra/vega.txt')
    vega = np.genfromtxt(vega_file, unpack=True)[: 2]
    vega[0] = vega[0] * 10000
    vega = rebin_spec(vega, x)*q.erg/q.s/q.cm**2/q.AA
    flam = np.trapz((vega[1]*f).to(q.erg/q.s/q.cm**2/q.AA), x=x)
    thru = np.trapz(f, x=x)
    self.ZeroPoint = (flam/thru).to(q.erg/q.s/q.cm**2/q.AA).value

    # Calculate the filter's properties
    self.filterID = os.path.splitext(os.path.basename(filepath))[0]
    self.WavelengthPeak = np.max(self.raw[0])
    f0 = f[: np.where(np.diff(f) > 0)[0][-1]]
    x0 = x[: np.where(np.diff(f) > 0)[0][-1]]
    self.WavelengthMin = np.interp(max(f)/100., f0, x0)
    f1 = f[::-1][: np.where(np.diff(f[::-1]) > 0)[0][-1]]
    x1 = x[::-1][: np.where(np.diff(f[::-1]) > 0)[0][-1]]
    self.WavelengthMax = np.interp(max(f)/100., f1, x1)
    self.WavelengthEff = np.trapz(f*x*vega, x=x)/np.trapz(f*vega, x=x)
    self.WavelengthMean = np.trapz(f*x, x=x)/np.trapz(f, x=x)
    self.WidthEff = np.trapz(f*x, x=x)
    piv = np.trapz(f*x, x=x)
    self.WavelengthPivot = np.sqrt(piv/np.trapz(f/x, x=x))
    pht = f*vega*x**2
    self.WavelengthPhot = np.trapz(pht, x=x)/np.trapz(f*vega*x, x=x)

    # Fix these two:
    self.WavelengthCen = self.WavelengthMean
    self.FWHM = self.WidthEff

    # Add missing attributes
    self.path = ''
    self.pixels_per_bin = self.raw.shape[-1]
    self.n_bins = 1
```

--------------------------------

### Load Grism Filter with Binning in Python

Source: https://context7.com/hover2pi/svo_filters/llms.txt

This code creates a binned filter for spectroscopic observations. It uses svo_filters with a filter name and bin parameters. The output includes binned wavelengths and throughputs; it is limited to filters that support binning and requires specifying bins or pixels.

```python
from svo_filters import svo

# Load HST/WFC3 G141 grism binned into 15 spectral channels
g141 = svo.Filter('WFC3_IR.G141', n_bins=15)

# Each bin has equal number of wavelength pixels
print(f"Number of bins: {g141.n_bins}")  # 15
print(f"Pixels per bin: {g141.pixels_per_bin}")  # 580
print(f"Binned wavelength shape: {g141.wave.shape}")  # (15, 580)
print(f"Binned throughput shape: {g141.throughput.shape}")  # (15, 580)

# Alternative: specify pixels per bin instead
g141_alt = svo.Filter('WFC3_IR.G141', pixels_per_bin=100)
print(f"Resulting bins: {g141_alt.n_bins}")  # Calculated automatically
```

--------------------------------

### Load Filter from TXT File (Python)

Source: https://github.com/hover2pi/svo_filters/blob/master/docs/_build/html/_modules/svo_filters/svo.html

Loads filter data from a text file, calculates various photometric properties, and derives filter attributes. It uses numpy for data manipulation and quantities for unit conversions. Dependencies include numpy, quantities, os, and resource_filename.

```python
def load_txt(self, filepath):
        """Load the filter from a txt file

        Parameters
        ----------
        file: str
            The filepath
        """
        self.raw = np.genfromtxt(filepath, unpack=True)

        # Convert to Angstroms if microns
        if self.raw[0][-1] < 100:
            self.raw[0] = self.raw[0] * 10000

        self.WavelengthUnit = str(q.AA)
        self.ZeroPointUnit = str(q.erg/q.s/q.cm**2/q.AA)
        x, f = self.raw

        # Get a spectrum of Vega
        vega_file = resource_filename('svo_filters', 'data/spectra/vega.txt')
        vega = np.genfromtxt(vega_file, unpack=True)[: 2]
        vega[0] = vega[0] * 10000
        vega = rebin_spec(vega, x)*q.erg/q.s/q.cm**2/q.AA
        flam = np.trapz((vega[1]*f).to(q.erg/q.s/q.cm**2/q.AA), x=x)
        thru = np.trapz(f, x=x)
        self.ZeroPoint = (flam/thru).to(q.erg/q.s/q.cm**2/q.AA).value

        # Calculate the filter's properties
        self.filterID = os.path.splitext(os.path.basename(filepath))[0]
        self.WavelengthPeak = np.max(self.raw[0])
        f0 = f[: np.where(np.diff(f) > 0)[0][-1]]
        x0 = x[: np.where(np.diff(f) > 0)[0][-1]]
        self.WavelengthMin = np.interp(max(f)/100., f0, x0)
        f1 = f[::-1][: np.where(np.diff(f[::-1]) > 0)[0][-1]]
        x1 = x[::-1][: np.where(np.diff(f[::-1]) > 0)[0][-1]]
        self.WavelengthMax = np.interp(max(f)/100., f1, x1)
        self.WavelengthEff = np.trapz(f*x*vega, x=x)/np.trapz(f*vega, x=x)
        self.WavelengthMean = np.trapz(f*x, x=x)/np.trapz(f, x=x)
        self.WidthEff = np.trapz(f*x, x=x)
        piv = np.trapz(f*x, x=x)
        self.WavelengthPivot = np.sqrt(piv/np.trapz(f/x, x=x))
        pht = f*vega*x**2
        self.WavelengthPhot = np.trapz(pht, x=x)/np.trapz(f*vega*x, x=x)

        # Fix these two:
        self.WavelengthCen = self.WavelengthMean
        self.FWHM = self.WidthEff

        # Add missing attributes
        self.path = ''
        self.pixels_per_bin = self.raw.shape[-1]
        self.n_bins = 1
```

--------------------------------

### Load and apply filter in Python

Source: https://context7.com/hover2pi/svo_filters/llms.txt

Loads a filter profile and applies it to a spectrum with error propagation. Systematic uncertainties are automatically added.

```python
j_band = svo.Filter('2MASS.J', n_bins=4)
filtered_flux, filtered_err = j_band.apply(spectrum_with_err)

print(f"Output flux: {filtered_flux}")
print(f"Propagated uncertainties: {filtered_err}")
print(f"Includes systematic: {j_band.systematics}")  # 0.02
```