Glue

https://docs.glueviz.org/en/stable/
Admin
Glue is a Python library designed to explore relationships within and among related datasets,...
Tokens:137,781
Snippets:1,516
Trust Score:8.9
Update:3 months ago
Show doc for...
Tokens:
Raw
### Get Glue Help

Source: https://docs.glueviz.org/en/stable/_sources/installation/installation.rst

Use 'glue --help' to see available command-line arguments and examples for Glue.

```bash
glue --help
```

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

### Start Glue Application

Source: https://docs.glueviz.org/en/stable/_sources/installation/installation.rst

Type 'glue' in the terminal to start the Glue application after installation.

```bash
glue
```

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

### setup()

Source: https://docs.glueviz.org/en/stable/api/glue_qt.viewers.scatter.setup.html

Initializes the scatter viewer setup. This function is part of the glue_qt.viewers.scatter module.

```APIDOC
## setup()

### Description
Initializes the scatter viewer setup. This function is part of the glue_qt.viewers.scatter module.

### Method
N/A (Function Call)

### Parameters
None explicitly documented.

### Response
None explicitly documented.
```

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

### Registering a Custom Viewer in __init__.py

Source: https://docs.glueviz.org/en/stable/_sources/customizing_guide/writing_plugin.rst

The setup function in your plugin's __init__.py file is used to register customizations. This example shows how to add a custom viewer.

```python
def setup():
    from .data_viewer import MyViewer
    from glue_qt.config import qt_client
    qt_client.add(MyViewer)
```

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

### setup()

Source: https://docs.glueviz.org/en/stable/api/glue_qt.viewers.histogram.setup.html

Initializes the histogram viewer setup. This function is part of the glue_qt.viewers.histogram module.

```APIDOC
## setup()

### Description
Initializes the histogram viewer setup. This function is part of the glue_qt.viewers.histogram module.

### Function Signature
`glue_qt.viewers.histogram.setup()`

### Parameters
This function does not take any parameters.

### Returns
This function does not explicitly return a value.
```

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

### Install Glueviz (New User)

Source: https://docs.glueviz.org/en/stable/_sources/installation/conda.rst

Install the glueviz package into the active 'glue-env' environment using mamba. This is for users who have just installed Mambaforge.

```bash
mamba install glueviz
```

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

### Install Glueviz (New User)

Source: https://docs.glueviz.org/en/stable/installation/conda.html

Install the glueviz package into the activated environment using mamba.

```bash
mamba install glueviz

```

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

### Manually Running Plugin Setup Function

Source: https://docs.glueviz.org/en/stable/_sources/customizing_guide/writing_plugin.rst

If a plugin fails to load, you can manually import and run its setup function to get more detailed error messages.

```python
python -c 'from myplugin import setup; setup()'
```

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

### start

Source: https://docs.glueviz.org/en/stable/api/glue_qt.app.application.GlueApplication.html

Shows the GUI and starts the application. This method blocks until the application is closed.

```APIDOC
## start(_size =None_, _position =None_, _block =True_, _maximized =True_)

### Description
Show the GUI and start the application.

### Parameters
* **size** (tuple[int, int], optional) - The default width/height of the application. If not provided, uses the full screen.
* **position** (tuple[int, int], optional) - The default position of the application.
* **block** (bool, optional) - Whether to block execution until the application is closed. Defaults to True.
* **maximized** (bool, optional) - Whether to start the application maximized. Defaults to True.
```

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

### setup()

Source: https://docs.glueviz.org/en/stable/api/glue_qt.viewers.profile.setup.html

The setup() function is used to initialize or configure viewer profiles within the Glue Qt environment. It is a core part of setting up the profile viewer's functionality.

```APIDOC
## setup()

### Description
Initializes or configures viewer profiles within the Glue Qt environment. This function is essential for setting up the profile viewer's functionality.

### Method
N/A (This appears to be a Python function call, not an HTTP endpoint)

### Endpoint
N/A

### Parameters
N/A (No parameters are explicitly documented in the provided text)

### Request Example
N/A

### Response
N/A (The response or return value is not explicitly documented in the provided text)
```

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

### setup()

Source: https://docs.glueviz.org/en/stable/api/glue_qt.viewers.table.setup.html

Initializes or sets up the table viewer component in Glue QT.

```APIDOC
## setup()

### Description
Initializes or sets up the table viewer component.

### Method
Python function call

### Endpoint
glu_qt.viewers.table.setup.setup()

### Parameters
This function does not appear to take any parameters.

### Request Example
```python
setup()
```

### Response
This function does not appear to have a documented return value.
```

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

### Install Glueviz Qt front-end

Source: https://docs.glueviz.org/en/stable/_sources/installation/pip.rst

Install the Qt-based front-end for Glueviz. This requires the glue-qt package.

```bash
pip install glue-qt[qt]
```

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

### Start Glue with a Python Script

Source: https://docs.glueviz.org/en/stable/python_guide/glue_from_python.html

This command shows how to execute a Python script that prepares data and starts the Glue application.

```bash
$ glue startup_script.py

```

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

### Install Glueviz with all dependencies (including Qt)

Source: https://docs.glueviz.org/en/stable/_sources/installation/pip.rst

Use this command to install Glueviz with all required and optional dependencies, ensuring PyQt5 is included for the Qt front-end.

```bash
pip install glueviz[qt]
```

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

### Install glue-vispy-viewers

Source: https://docs.glueviz.org/en/stable/installation/pip.html

Install the package for 3D viewers within glueviz.

```bash
pip install glue-vispy-viewers

```

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

### setup()

Source: https://docs.glueviz.org/en/stable/api/glue_qt.viewers.image.setup.html

Initializes and sets up the image viewer component. This function is the primary entry point for configuring the image viewer.

```APIDOC
## setup()

### Description
Initializes and sets up the image viewer component. This function is the primary entry point for configuring the image viewer.

### Method
`setup()`

### Parameters
This function does not take any parameters.

### Request Example
```python
from glue_qt.viewers.image import setup

setup()
```

### Response
This function does not return any value. Its purpose is to configure the application's state.
```

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

### Install glue-core (base package)

Source: https://docs.glueviz.org/en/stable/installation/pip.html

Install the base glue-core package if you only need the core functionality without any front-end.

```bash
pip install glue-core

```

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

### Start and Display Glue Application GUI

Source: https://docs.glueviz.org/en/stable/_modules/glue_qt/app/application.html

Shows the main Glue GUI window and starts the Qt event loop. Allows for specifying window size, position, and whether it should be maximized.

```python
    def start(self, size=None, position=None, block=True, maximized=True):
        """
        Show the GUI and start the application.

        Parameters
        ----------
        size : (int, int) Optional
            The default width/height of the application.
            If not provided, uses the full screen
        position : (int, int) Optional
            The default position of the application
        """
        if maximized:
            self.showMaximized()
        else:
            self.show()
        if size is not None:
            self.resize(*size)
        if position is not None:
            self.move(*position)

        self.raise_()  # bring window to front
```

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

### Install Glueviz Qt front-end with PyQt6

Source: https://docs.glueviz.org/en/stable/_sources/installation/pip.rst

Install the Qt-based front-end for Glueviz and specify PyQt6 as the Qt binding.

```bash
pip install glue-qt PyQt6
```

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

### Install Glueviz core package

Source: https://docs.glueviz.org/en/stable/_sources/installation/pip.rst

Install only the base Glueviz package without any front-end or specific viewers.

```bash
pip install glue-core
```

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

### Install Glueviz (Existing User)

Source: https://docs.glueviz.org/en/stable/installation/conda.html

Install the glueviz package from the conda-forge channel into the activated environment.

```bash
mamba install -c conda-forge glueviz

```

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

### Install glue-samp using Pip

Source: https://docs.glueviz.org/en/stable/_sources/customizing_guide/available_plugins.rst

Install the glue-samp plugin using pip for environments not using conda.

```bash
pip install glue-samp
```

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

### Load Data and Start Glue Application

Source: https://docs.glueviz.org/en/stable/python_guide/glue_from_python.html

This script demonstrates loading two datasets from FITS and VOTable files, bundling them into a DataCollection, linking their positional attributes using LinkSame, and then starting the Glue application with the prepared data.

```python
from glue.core.data_factories import load_data
from glue.core import DataCollection
from glue.core.link_helpers import LinkSame
from glue_qt.app.application import GlueApplication

# load 2 datasets from files
image = load_data('w5.fits')
catalog = load_data('w5_psc.vot')
dc = DataCollection([image, catalog])

# link positional information
dc.add_link(LinkSame(image.id['Right Ascension'], catalog.id['RAJ2000']))
dc.add_link(LinkSame(image.id['Declination'], catalog.id['DEJ2000']))

# start Glue
app = GlueApplication(dc)
app.start()

```

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

### Registering a Setup Function for Court Markings

Source: https://docs.glueviz.org/en/stable/customizing_guide/custom_viewer.html

This snippet demonstrates how to register a setup function using the `@bball.setup` decorator. This function is called once when the viewer is created to draw static elements like court markings.

```python
from glue import custom_viewer

from matplotlib.colors import LogNorm
from matplotlib.patches import Circle, Rectangle, Arc
from matplotlib.lines import Line2D

bball = custom_viewer('Shot Plot',
                      x='att(x)',
                      y='att(y)')


@bball.plot_data
def show_hexbin(axes, x, y):
    axes.hexbin(x, y,
                cmap='Purples',
                gridsize=40,
                norm=LogNorm(),
                mincnt=1)


@bball.plot_subset
def show_points(axes, x, y, style):
    axes.plot(x, y, 'o',
              alpha=style.alpha,
              mec=style.color,
              mfc=style.color,
              ms=style.markersize)


@bball.setup
def draw_court(axes):

    c = '#777777'
    opts = dict(fc='none', ec=c, lw=2)
    hoop = Circle((0, 63), radius=9, **opts)
    axes.add_patch(hoop)

    box = Rectangle((-6 * 12, 0), 144, 19 * 12, **opts)
    axes.add_patch(box)

    inner = Arc((0, 19 * 12), 144, 144, theta1=0, theta2=180, **opts)
    axes.add_patch(inner)

    threept = Arc((0, 63), 474, 474, theta1=0, theta2=180, **opts)
    axes.add_patch(threept)

    opts = dict(c=c, lw=2)
    axes.add_line(Line2D([237, 237], [0, 63], **opts))
    axes.add_line(Line2D([-237, -237], [0, 63], **opts))

    axes.set_ylim(0, 400)
    axes.set_aspect('equal', adjustable='datalim')
```

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

### Setup ProfileViewer in GlueQt Client

Source: https://docs.glueviz.org/en/stable/_modules/glue_qt/viewers/profile.html

Adds the ProfileViewer to the GlueQt client configuration. This function should be called during application setup.

```python
from glue_qt.config import qt_client
qt_client.add(ProfileViewer)
```

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

### Install Mambaforge

Source: https://docs.glueviz.org/en/stable/installation/conda.html

For new conda users, download and install Mambaforge using the provided script.

```bash
bash MambaForge-*.sh

```

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

### Starting Glue with Verbose Logging

Source: https://docs.glueviz.org/en/stable/_sources/customizing_guide/writing_plugin.rst

Start Glue with the -v flag to enable verbose logging, which helps in diagnosing plugin loading issues.

```bash
glue -v
```

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

### CustomViewer.setup

Source: https://docs.glueviz.org/en/stable/api/glue_qt.viewers.custom.custom_viewer.CustomViewer.html

This method can be overridden by users to perform custom setup operations when a viewer is initialized. It is called automatically and does not need to be called directly.

```APIDOC
## CustomViewer.setup()

### Description
Register a new custom method like "plot_data". Users need not call this directly - it is called when a method is overridden or decorated.

### Method Signature
`setup()`

### Parameters
None
```

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

### Install glue-geospatial using Pip

Source: https://docs.glueviz.org/en/stable/customizing_guide/available_plugins.html

Use this command to install the glue-geospatial plugin if you are not using the Mamba package manager.

```bash
pip install glue-geospatial

```

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

### Emcee Plugin Example for Gaussian Fitting

Source: https://docs.glueviz.org/en/stable/_sources/customizing_guide/fitting.rst

This Python script demonstrates a comprehensive example of Gaussian fitting using the Emcee plugin, combining various concepts for advanced analysis.

```python
import numpy as np
import emcee
import corner
import matplotlib.pyplot as plt

# Define the model (Gaussian)
def gaussian(theta, x):
    amp, mu, sig = theta
    return amp * np.exp(-0.5 * ((x - mu) / sig) ** 2)

# Define the log probability function
def log_prob(theta, x, y, yerr):
    amp, mu, sig = theta
    if amp <= 0 or sig <= 0:
        return -np.inf  # Prior for amplitude and sigma
    model = gaussian(theta, x)
    chi2 = np.sum(((y - model) / yerr) ** 2)
    return -0.5 * chi2

# Generate some synthetic data
x = np.linspace(-10, 10, 100)
yerr = np.random.uniform(0.1, 0.5, 100)
y = 5.0 * np.exp(-0.5 * ((x - 1.0) / 2.0) ** 2) + np.random.normal(0, yerr, 100)

# Set up the MCMC sampler
ndim = 3  # Number of parameters (amp, mu, sig)
nwalkers = 50
initial_state = np.random.uniform(0.1, 10, (nwalkers, ndim)) # Initial guesses for parameters

sampler = emcee.EnsembleSampler(nwalkers, ndim, log_prob, args=(x, y, yerr))

# Run the MCMC
print("Running burn-in...")
state = sampler.run_mcmc(initial_state, 1000)
sampler.reset()

print("Running production...")
sampler.run_mcmc(state, 10000)

# Analyze the results
flat_samples = sampler.get_chain(discard=100, thin=10, flat=True)

# Plot the corner plot
figure = corner.corner(flat_samples, labels=["amp", "mu", "sig"], truths=[5.0, 1.0, 2.0])
figure.suptitle("Gaussian Fitting with Emcee")
plt.show()

# Plot the best fit
mean_params = np.mean(flat_samples, axis=0)
plt.errorbar(x, y, yerr=yerr, fmt=".b", capsize=2)
plt.plot(x, gaussian(mean_params, x), "-r", label="Best Fit")
plt.xlabel("x")
plt.ylabel("y")
plt.legend()
plt.title("Gaussian Fit to Data")
plt.show()

```

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

### Programmatic Glue Startup with Custom Data

Source: https://docs.glueviz.org/en/stable/developer_guide/data.html

This snippet shows how to programmatically start a Glue application with a custom data object. It involves creating an instance of your custom data class, adding it to a DataCollection, and then initializing and starting the GlueApplication.

```python
# Construct your data object
d = MyCustomData(...)

# Create glue application and start
dc = DataCollection([d])
ga = GlueApplication(dc)
ga.start()

```

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

### Install Latest Glue-QT from Git

Source: https://docs.glueviz.org/en/stable/_sources/installation/developer.rst

Install the most recent developer version of the glue-qt package, which provides the Qt desktop application interface, directly from its GitHub repository using pip. This is necessary if you intend to use the graphical user interface.

```bash
pip install git+https://github.com/glue-viz/glue-qt
```

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

### Launch Glueviz Application

Source: https://docs.glueviz.org/en/stable/getting_started/index.html

Launch the Glueviz application from the command line. This command is used after installing Glue.

```bash
glue

```

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

### exec_

Source: https://docs.glueviz.org/en/stable/api/glue_qt.app.application.GlueApplication.html

Shows the GUI and starts the application. This method blocks until the application is closed.

```APIDOC
## exec_(_size =None_, _position =None_, _block =True_, _maximized =True_)

### Description
Show the GUI and start the application.

### Parameters
* **size** (tuple[int, int], optional) - The default width/height of the application. If not provided, uses the full screen.
* **position** (tuple[int, int], optional) - The default position of the application.
* **block** (bool, optional) - Whether to block execution until the application is closed. Defaults to True.
* **maximized** (bool, optional) - Whether to start the application maximized. Defaults to True.
```

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

### Install Latest Glue Core from Git

Source: https://docs.glueviz.org/en/stable/_sources/installation/developer.rst

Install the most recent developer version of the glue-core package directly from its GitHub repository using pip. This is recommended for developers wanting the latest features or to test changes.

```bash
pip install git+https://github.com/glue-viz/glue
```

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

### Setup GlueQt TableViewer

Source: https://docs.glueviz.org/en/stable/_modules/glue_qt/viewers/table.html

Adds the TableViewer to the GlueQt client. This function should be called during application initialization.

```python
from glue_qt.config import qt_client

def setup():
    qt_client.add(TableViewer)
```

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

### Minimal Custom Data Class Example

Source: https://docs.glueviz.org/en/stable/developer_guide/data.html

This example demonstrates a basic custom data class, `RandomData`, that inherits from `BaseCartesianData`. It generates random data on-the-fly and includes methods for retrieving data, masks, statistics, and histograms. This class is then used to initialize and start a Glue session.

```python
import numpy as np

from glue.core.component_id import ComponentID
from glue.core.data import BaseCartesianData
from glue.utils import view_shape


class RandomData(BaseCartesianData):

    def __init__(self):
        super(RandomData, self).__init__()
        self.data_cid = ComponentID(label='data', parent=self)

    @property
    def label(self):
        return "Random Data"

    @property
    def shape(self):
        return (512, 512, 512)

    @property
    def main_components(self):
        return [self.data_cid]

    def get_kind(self, cid):
        return 'numerical'

    def get_data(self, cid, view=None):
        if cid is self.data_cid:
            return np.random.random(view_shape(self.shape, view))
        else:
            return super(RandomData, self).get_data(cid, view=view)

    def get_mask(self, subset_state, view=None):
        return subset_state.to_mask(self, view=view)

    def compute_statistic(self, statistic, cid,
                          axis=None, finite=True,
                          positive=False, subset_state=None,
                          percentile=None, random_subset=None):
        if axis is None:
            if statistic == 'minimum':
                return 0
            elif statistic == 'maximum':
                if cid in self.pixel_component_ids:
                    return self.shape[cid.axis]
                else:
                    return 1
            elif statistic == 'mean' or statistic == 'median':
                return 0.5
            elif statistic == 'percentile':
                return percentile / 100
            elif statistic == 'sum':
                return self.size / 2
        else:
            final_shape = tuple(self.shape[i] for i in range(self.ndim)
                                if i not in axis)
            return np.random.random(final_shape)

    def compute_histogram(self, cid,
                          range=None, bins=None, log=False,
                          subset_state=None, subset_group=None):
        return np.random.random(bins) * 100


# We now create a data object using the above class,
# and launch a a glue session

from glue.core import DataCollection
from glue.app.application import GlueApplication

d = RandomData()
dc = DataCollection([d])
ga = GlueApplication(dc)
ga.start()

```

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

### Example Usage of ButtonProperty

Source: https://docs.glueviz.org/en/stable/_modules/glue_qt/utils/widget_properties.html

Demonstrates how to use ButtonProperty to control a QCheckBox's state via a Python boolean attribute. This allows setting and getting the check state as if it were a simple boolean.

```python
class Foo(object):
    bar = ButtonProperty('_button')

    def __init__(self):
        self._button = QtWidgets.QCheckBox()

f = Foo()
f.bar = True  # equivalent to f._button.setChecked(True)
assert f.bar == True
```

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

### Setup Application User Interface

Source: https://docs.glueviz.org/en/stable/_modules/glue_qt/app/application.html

Loads the UI from a file, sets up the central widget, configures the tab bar, and initializes the data layers widget and toolbar.

```python
self._ui = load_ui('application.ui', None,
                           directory=os.path.dirname(__file__))
        self.setCentralWidget(self._ui)
        self._ui.tabWidget.setTabBar(GlueTabBar())

        lw = LayerTreeWidget(session=self._session)
        lw.set_checkable(False)
        self._vb = QtWidgets.QVBoxLayout()
        self._vb.setContentsMargins(0, 0, 0, 0)
        self._vb.addWidget(lw)
        self._ui.data_layers.setLayout(self._vb)
        self._layer_widget = lw

        # Data toolbar

        self._data_toolbar = QtWidgets.QToolBar("Session and Data toolbar")

        self._data_toolbar.setIconSize(QtCore.QSize(16, 16))

        self._button_open_session = QtWidgets.QToolButton()
        self._button_open_session.setText("Open Session")
        self._button_open_session.setIcon(get_icon('glue_open'))
        self._button_open_session.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
        self._button_open_session.clicked.connect(self._restore_session)

        self._data_toolbar.addWidget(self._button_open_session)

        self._button_save_session = QtWidgets.QToolButton()
        self._button_save_session.setText("Export Session")
        self._button_save_session.setIcon(get_icon('glue_filesave'))
        self._button_save_session.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
        self._button_save_session.clicked.connect(self._choose_save_session)

        self._data_toolbar.addWidget(self._button_save_session)
        self._button_open_data = QtWidgets.QToolButton()
        self._button_open_data.setText("Import Data")
        self._button_open_data.setIcon(get_icon('glue_open'))
        self._button_open_data.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
        self._button_open_data.clicked.connect(self._import_helper._choose_load_data_wizard)

        self._data_toolbar.addWidget(self._button_open_data)

        self._button_save_data = QtWidgets.QToolButton()
        self._button_save_data.setText("Export Data/Subsets")
        self._button_save_data.setIcon(get_icon('glue_filesave'))
        self._button_save_data.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
        self._button_save_data.clicked.connect(self._choose_save_data)

        self._data_toolbar.addWidget(self._button_save_data)
```

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

### Custom Viewer Subclass for Shot Chart

Source: https://docs.glueviz.org/en/stable/customizing_guide/custom_viewer.html

Subclass CustomViewer to create a specialized 'Shot Plot' viewer. This example demonstrates how to define attributes, implement selection state creation, data plotting, subset plotting, and setup for visual elements like a basketball court.

```python
from glue_qt.viewers.custom import CustomViewer

from glue.core.subset import RoiSubsetState

from matplotlib.colors import LogNorm
from matplotlib.patches import Circle, Rectangle, Arc
from matplotlib.lines import Line2D
import numpy as np


class BBall(CustomViewer):
    name = 'Shot Plot'
    x = 'att(x)'
    y = 'att(y)'
    bins = (10, 100)
    hitrate = False
    color = ['Reds', 'Purples']
    hit = 'att(shot_made)'

    def make_selector(self, roi, x, y):

        state = RoiSubsetState()
        state.roi = roi
        state.xatt = x.id
        state.yatt = y.id

        return state

    def plot_data(self, axes, x, y,
                  hit, hitrate, color, bins):
        if hitrate:
            axes.hexbin(x, y, hit,
                        reduce_C_function=lambda x: np.array(x).mean(),
                        cmap=color,
                        gridsize=bins,
                        mincnt=5)
        else:
            axes.hexbin(x, y,
                        cmap=color,
                        gridsize=bins,
                        norm=LogNorm(),
                        mincnt=1)

    def plot_subset(self, axes, x, y, style):
        axes.plot(x, y, 'o',
                  alpha=style.alpha,
                  mec=style.color,
                  mfc=style.color,
                  ms=style.markersize)

    def setup(self, axes):

        c = '#777777'
        opts = dict(fc='none', ec=c, lw=2)
        hoop = Circle((0, 63), radius=9, **opts)
        axes.add_patch(hoop)

        box = Rectangle((-6 * 12, 0), 144, 19 * 12, **opts)
        axes.add_patch(box)

        inner = Arc((0, 19 * 12), 144, 144, theta1=0, theta2=180, **opts)
        axes.add_patch(inner)

        threept = Arc((0, 63), 474, 474, theta1=0, theta2=180, **opts)
        axes.add_patch(threept)

        opts = dict(c=c, lw=2)
        axes.add_line(Line2D([237, 237], [0, 63], **opts))
        axes.add_line(Line2D([-237, -237], [0, 63], **opts))

        axes.set_ylim(0, 400)
        axes.set_aspect('equal', adjustable='datalim')

```

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

### Defining Plugin Entry Points in setup.py

Source: https://docs.glueviz.org/en/stable/_sources/customizing_guide/writing_plugin.rst

The setup.py file defines entry points to inform Glue about your plugin. This example shows the structure for registering a plugin named 'myplugin'.

```python
entry_points = """
[glue.plugins]
myplugin=myplugin:setup
"""
```

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

### Activate Conda environment

Source: https://docs.glueviz.org/en/stable/_sources/installation/conda.rst

Switch to the newly created 'glue-env' environment to begin installing packages within it.

```bash
mamba activate glue-env
```

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

### Create a pandas DataFrame

Source: https://docs.glueviz.org/en/stable/_sources/python_guide/data_translation.rst

Initialize a pandas DataFrame with sample data. This is often the starting point for data translation into glue.

```python
from pandas import DataFrame
df1 = DataFrame()
df1['a'] = [1.2, 3.4, 2.9]
df1['g'] = ['r', 'q', 's']
df1
```

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

### Specify Startup Action via Command Line

Source: https://docs.glueviz.org/en/stable/customizing_guide/customization.html

Run Glue with the `--startup` flag followed by the action name to execute a custom startup action.

```bash
glue --startup=action_name

```

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

### Install Mambaforge

Source: https://docs.glueviz.org/en/stable/_sources/installation/conda.rst

For new conda users, download and install the Mambaforge distribution. This script is used for Linux and MacOS X installations.

```bash
bash MambaForge-*.sh
```

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

### Example Decorator for Custom Viewer

Source: https://docs.glueviz.org/en/stable/_modules/glue_qt/viewers/custom/custom_viewer.html

This example shows how to use the custom_viewer decorator to define a custom viewer named 'Example'. It associates a plot_data function with the viewer.

```python
v = custom_viewer('Example', checkbox=False)

@v.plot_data
def plot(checkbox, axes):
    axes.plot([1, 2, 3])
```

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

### Install Glueviz (Existing User)

Source: https://docs.glueviz.org/en/stable/_sources/installation/conda.rst

Install the glueviz package from the conda-forge channel into the active 'glue-env' environment using mamba. This is for existing conda users who have installed mamba.

```bash
mamba install -c conda-forge glueviz
```

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

### Initialize Application Window and UI Elements

Source: https://docs.glueviz.org/en/stable/_modules/glue_qt/app/application.html

Sets up the main application window, including window title, icon, close behavior, tab widget properties, and initializes internal components like actions and the UI layout.

```python
self.set_window_title()
        self.setWindowIcon(icon)
        self.setAttribute(Qt.WA_DeleteOnClose)
        self._actions = {}
        self._terminal = None
        self._setup_ui()
        self.tab_widget.setMovable(True)
        self.tab_widget.setTabsClosable(True)

        # The following is a counter that never goes down, even if tabs are
        # deleted (this is by design, to avoid having two tabs called the
        # same if a tab is removed then a new one added again)
        self._total_tab_count = 0

        lwidget = self._layer_widget
        a = PlotAction(lwidget, self)
        lwidget.ui.layerTree.addAction(a)

        self._tweak_geometry()
        self._create_actions()
        self._create_menu()
        self._connect()
        self.new_tab()
        self._update_viewer_in_focus()
```

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

### Initialize and Execute Qt Plugin Manager

Source: https://docs.glueviz.org/en/stable/_modules/glue_qt/app/application.html

Initializes and displays the Qt Plugin Manager UI. It retrieves the list of installed plugins from glue.main.

```python
def plugin_manager(self, *args):
        from glue.main import _installed_plugins
        pm = QtPluginManager(installed=_installed_plugins)
        pm.ui.exec_()
```

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

### Run Startup Action by Name

Source: https://docs.glueviz.org/en/stable/_modules/glue_qt/app/application.html

Executes a predefined startup action based on its name. Raises an exception if the action name is not recognized.

```python
if name in startup_action.members:
            startup_action.members[name](self.session, self.data_collection)
        else:
            raise Exception("Unknown startup action: {0}".format(name))
```

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

### Initialize Viewer Toolbar

Source: https://docs.glueviz.org/en/stable/_modules/glue_qt/viewers/common/data_viewer.html

Sets up the main toolbar for the viewer, including adding custom tools and subtools.

```python
def initialize_toolbar(self):

        from glue.config import viewer_tool

        self.toolbar = self._toolbar_cls(self, default_mouse_mode_cls=self._default_mouse_mode_cls)

        # Need to include tools and subtools declared by parent classes unless
        # specified otherwise
        tool_ids, subtool_ids = get_viewer_tools(self.__class__)

        for tool_id in tool_ids:
            mode_cls = viewer_tool.members[tool_id]
            if tool_id in subtool_ids:
                subtools = []
                for subtool_id in subtool_ids[tool_id]:
                    subtools.append(viewer_tool.members[subtool_id](self))
                mode = mode_cls(self, subtools=subtools)
            else:
                mode = mode_cls(self)
            self.toolbar.add_tool(mode)

        self.addToolBar(self.toolbar)

        self.toolbar_added.emit()
```

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

### Install glue-samp using Mamba

Source: https://docs.glueviz.org/en/stable/_sources/customizing_guide/available_plugins.rst

Install the glue-samp plugin using the conda package manager (mamba).

```bash
mamba install -c conda-forge glue-samp
```

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

### Command-line Execution of Startup Actions

Source: https://docs.glueviz.org/en/stable/api/glue_qt.config.StartupActionRegistry.html

Startup actions can be triggered from the command line by specifying comma-separated action names using the --startup argument.

```bash
glue --startup=mystartupaction
```

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

### Install glue-wwt using Pip

Source: https://docs.glueviz.org/en/stable/_sources/customizing_guide/available_plugins.rst

Install the glue-wwt plugin using pip for environments not using conda.

```bash
pip install glue-wwt
```

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

### Install glue-wwt using Mamba

Source: https://docs.glueviz.org/en/stable/_sources/customizing_guide/available_plugins.rst

Install the glue-wwt plugin using the conda package manager (mamba).

```bash
mamba install -c conda-forge glue-wwt
```

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

### GlueApplication Initialization

Source: https://docs.glueviz.org/en/stable/_modules/glue_qt/app/application.html

Initializes the GlueApplication, handling existing Qt applications, setting up helpers, and loading plugins. It configures the main window icon and ensures plugins are loaded.

```python
class GlueApplication(Application, QtWidgets.QMainWindow):

    """ The main GUI application for the Qt frontend"""

    def __init__(self, data_collection=None, session=None):

        # At this point we need to check if a Qt application already exists -
        # this happens for example if using the %gui qt/qt5 mode in Jupyter. We
        # should keep a reference to the original icon so that we can restore it
        # later
        self._original_app = QtWidgets.QApplication.instance()
        if self._original_app is not None:
            self._original_icon = self._original_app.windowIcon()

        self._export_helper = ExportHelper(self)
        self._import_helper = ImportHelper(self)

        # Now we can get the application instance, which involves setting it
        # up if it doesn't already exist.
        self.app = get_qapp()

        QtWidgets.QMainWindow.__init__(self)
        Application.__init__(self, data_collection=data_collection,
                             session=session)

        # Pull in any keybindings from an external file
        self.keybindings = keyboard_shortcut

        icon = get_icon('app_icon')
        self.app.setWindowIcon(icon)

        # Even though we loaded the plugins in start_glue, we re-load them here
        # in case glue was started directly by initializing this class.
        load_plugins(require_qt_plugins=True)
```

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

### Install glue-medical using Pip

Source: https://docs.glueviz.org/en/stable/customizing_guide/available_plugins.html

Use this command to install the glue-medical plugin if you are not using the Mamba package manager.

```bash
pip install glue-medical

```

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

### Create Plugins Menu

Source: https://docs.glueviz.org/en/stable/_modules/glue_qt/app/application.html

Sets up the 'Plugins' menu, including the plugin manager action and dynamically adding any available plugins.

```python
        menu = QtWidgets.QMenu(mbar)
        menu.setTitle("&Plugins")
        menu.addAction(self._actions['plugin_manager'])
        menu.addSeparator()

        if 'plugins' in self._actions:
            for plugin in self._actions['plugins']:
                menu.addAction(plugin)

        mbar.addMenu(menu)
```

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

### Install astrodendro Package

Source: https://docs.glueviz.org/en/stable/_sources/gui_guide/dendro.rst

Install the astrodendro package using pip. This is required to enable the dendrogram viewer in Glue.

```bash
pip install astrodendro
```

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

### Connect Application Signals and Setup

Source: https://docs.glueviz.org/en/stable/_modules/glue_qt/app/application.html

Initializes drag-and-drop support, sets up the layer widget, and connects signals for tab close requests and tab changes to their respective slots.

```python
    def _connect(self):
        self.setAcceptDrops(True)
        self._layer_widget.setup(self._data)

        self.tab_widget.tabCloseRequested.connect(self.close_tab)
        self.tab_widget.currentChanged.connect(self._update_viewer_in_focus)
```

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

### Deferred Loading of a Qt Viewer

Source: https://docs.glueviz.org/en/stable/customizing_guide/customization.html

Place your viewer definition and setup function in a separate file. This defers the import of Qt until the viewer is actually needed.

```python
class MyQtViewer(...):
    ...

def setup():
    from glue_qt.config import qt_client
    qt_client.add(MyQtViewer)
```

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

### Install Mamba with Conda

Source: https://docs.glueviz.org/en/stable/_sources/installation/conda.rst

For existing conda users, install the mamba package from the conda-forge channel using the conda command.

```bash
conda install -c conda-forge mamba
```

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

### Create Edit and View Menus

Source: https://docs.glueviz.org/en/stable/_modules/glue_qt/app/application.html

Sets up the 'Edit' menu with undo/redo actions and the 'View' menu with an action to show the console log.

```python
        menu = QtWidgets.QMenu(mbar)
        menu.setTitle("&Edit ")
        menu.addAction(self._actions['undo'])
        menu.addAction(self._actions['redo'])
        mbar.addMenu(menu)

        menu = QtWidgets.QMenu(mbar)
        menu.setTitle("&View ")

        a = QtWidgets.QAction("&Console Log", menu)
        a.triggered.connect(self._log._show)
        menu.addAction(a)
        mbar.addMenu(menu)
```

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

### StartupActionRegistry.add

Source: https://docs.glueviz.org/en/stable/_sources/api/glue_qt.config.StartupActionRegistry.rst

The add method registers a new startup action with the registry.

```APIDOC
## add

### Description
Registers a new startup action with the registry.

### Method
N/A (This is a method of a class)

### Parameters
None explicitly documented.

### Response
None explicitly documented.
```

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

### Installing a Plugin in Develop Mode

Source: https://docs.glueviz.org/en/stable/_sources/customizing_guide/writing_plugin.rst

Use pip to install your plugin in 'develop' mode, allowing changes to be reflected without re-installation.

```bash
pip install -e .
```

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

### StartupActionRegistry.add()

Source: https://docs.glueviz.org/en/stable/api/glue_qt.config.StartupActionRegistry.html

Adds a startup function to the registry. These functions are executed after Glue has started and data is loaded, useful for setting up layouts and creating links. Startup actions can be triggered via command-line arguments or the `startup` keyword in `GlueApplication`.

```APIDOC
## StartupActionRegistry.add()

### Description
Add a startup function to the registry. This is a function that will get called once glue has been started and any data loaded, and can be used to set up specific layouts and create links. Startup actions are triggered by either specifying comma-separated names of actions on the command-line or by passing an iterable of startup action names to the `startup` keyword of `GlueApplication`. The startup function will be given the session object and the data collection object.

### Method
add

### Parameters
#### Path Parameters
- **_startup_name_** (string) - Description not provided
- **_startup_function_** (function) - Description not provided
```

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

### Install PySide from Conda-Forge

Source: https://docs.glueviz.org/en/stable/known_issues.html

Workaround for Qt internal error on macOS: install PySide from the 'conda-forge' channel to avoid issues with the 'defaults' channel package.

```bash
conda install -c conda-forge pyside

```

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

### Registering Startup Actions

Source: https://docs.glueviz.org/en/stable/_modules/glue_qt/config.html

The StartupActionRegistry manages functions to be executed after Glue starts and data is loaded. Actions can be triggered via the command line or GlueApplication initialization.

```python
class StartupActionRegistry(DictRegistry):


    def add(self, startup_name, startup_function):
        """
        Add a startup function to the registry. This is a function that will
        get called once glue has been started and any data loaded, and can
        be used to set up specific layouts and create links.

        Startup actions are triggered by either specifying comma-separated names
        of actions on the command-line::

            glue --startup=mystartupaction

        or by passing an iterable of startup action names to the ``startup``
        keyword of ``GlueApplication``.

        The startup function will be given the session object and the data
        collection object.
        """
        if startup_name in self.members:
            raise ValueError("A startup action with the name '{0}' already exists".format(startup_name))
        else:
            self.members[startup_name] = startup_function


    def __call__(self, name):
        def adder(func):
            self.add(name, func)
            return func
        return adder
```

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

### Create Help Menu with Online Documentation Link

Source: https://docs.glueviz.org/en/stable/_modules/glue_qt/app/application.html

Adds the 'Help' menu, including an action to open the online documentation in a web browser. This is intended to be the native Mac 'Help' menu.

```python
        # trigger inclusion of Mac Native "Help" tool
        menu = mbar.addMenu("&Help")

        a = QtWidgets.QAction("&Online Documentation", menu)
        a.triggered.connect(nonpartial(webbrowser.open, DOCS_URL))
        menu.addAction(a)
```

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

### Install glue-geospatial with Pip

Source: https://docs.glueviz.org/en/stable/_sources/customizing_guide/available_plugins.rst

Install the glue-geospatial plugin package using pip. This plugin adds support for geospatial data, including GeoTIFF files.

```bash
pip install glue-geospatial
```

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

### Programmatic Execution of Startup Actions

Source: https://docs.glueviz.org/en/stable/api/glue_qt.config.StartupActionRegistry.html

Startup actions can also be triggered programmatically by passing an iterable of startup action names to the 'startup' keyword argument of GlueApplication.

```python
app = GlueApplication(startup=['action1', 'action2'])

```

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

### Install glue-geospatial with Mamba

Source: https://docs.glueviz.org/en/stable/_sources/customizing_guide/available_plugins.rst

Install the glue-geospatial plugin package using mamba. This plugin adds support for geospatial data, including GeoTIFF files.

```bash
mamba install -c conda-forge glue-geospatial
```

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

### Install glue-medical with Pip

Source: https://docs.glueviz.org/en/stable/_sources/customizing_guide/available_plugins.rst

Install the glue-medical plugin package using pip. This plugin provides functionality for medical imaging, including a DICOM reader.

```bash
pip install glue-medical
```

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

### Adding a Startup Action Function

Source: https://docs.glueviz.org/en/stable/api/glue_qt.config.StartupActionRegistry.html

The add method registers a startup function. This function will be called after Glue starts and data is loaded, and can be used to configure layouts and create links. The startup function receives the session and data collection objects.

```python
registry.add('my_startup_action', my_startup_function)
```

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

### Install glue-medical with Mamba

Source: https://docs.glueviz.org/en/stable/_sources/customizing_guide/available_plugins.rst

Install the glue-medical plugin package using mamba. This plugin provides functionality for medical imaging, including a DICOM reader.

```bash
mamba install -c conda-forge glue-medical
```

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

### Programmatic Startup with Custom Data Object

Source: https://docs.glueviz.org/en/stable/_sources/developer_guide/data.rst

This snippet shows how to construct a custom data object and start a Glue application programmatically with it. This is useful during the initial development of custom data objects.

```python
# Construct your data object
d = MyCustomData(...)

# Create glue application and start
dc = DataCollection([d])
ga = GlueApplication(dc)
ga.start()
```

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

### Programmatic Viewer Configuration

Source: https://docs.glueviz.org/en/stable/_sources/python_guide/data_viewer_options.rst

Demonstrates creating a Glue application, adding data, creating a scatter viewer, and programmatically configuring viewer and layer states, including axis mapping and log scaling.

```python
import numpy as np

from glue.core import Data, DataCollection
from glue_qt.app.application import GlueApplication
from glue_qt.viewers.scatter import ScatterViewer

# create some data
d = Data(x=np.random.random(100), y=np.random.random(100))
dc = DataCollection([d])

# create a GUI session
ga = GlueApplication(dc)

# plot x vs y, flip the x axis, log-scale y axis
scatter = ga.new_data_viewer(ScatterViewer)
scatter.add_data(d)

# Modify viewer-level options
scatter.state.x_att = d.id['x']
scatter.state.y_att = d.id['y']
scatter.state.y_log = True

# Modify settings for the (only) layer shown
scatter.state.layers[0].color = 'blue'

# show the GUI
ga.start()
```

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

### Install glue-vispy-viewers with Pip

Source: https://docs.glueviz.org/en/stable/_sources/customizing_guide/available_plugins.rst

Install the glue-vispy-viewers plugin package using pip. This package adds 3D scatter plot and volume rendering viewers.

```bash
pip install glue-vispy-viewers
```

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

### Install glue-vispy-viewers with Mamba

Source: https://docs.glueviz.org/en/stable/_sources/customizing_guide/available_plugins.rst

Install the glue-vispy-viewers plugin package using mamba. This package adds 3D scatter plot and volume rendering viewers.

```bash
mamba install -c conda-forge glue-vispy-viewers
```

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

### Install PySide from Conda-Forge

Source: https://docs.glueviz.org/en/stable/_sources/known_issues.rst

Workaround for the 'qt_menu.nib could not be loaded' error on MacOS X when using PySide. Install PySide from the 'conda-forge' channel instead of 'defaults'.

```bash
conda install -c conda-forge pyside
```

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

### Install glue-plotly with Pip

Source: https://docs.glueviz.org/en/stable/_sources/customizing_guide/available_plugins.rst

Install the glue-plotly plugin package using pip. This plugin enables exporting plots to standalone interactive Plotly HTML pages.

```bash
pip install glue-plotly
```

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

### Install glue-plotly with Mamba

Source: https://docs.glueviz.org/en/stable/_sources/customizing_guide/available_plugins.rst

Install the glue-plotly plugin package using mamba. This plugin enables exporting plots to standalone interactive Plotly HTML pages.

```bash
mamba install -c conda-forge glue-plotly
```

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

### Example Subclass for Custom Viewer

Source: https://docs.glueviz.org/en/stable/_modules/glue_qt/viewers/custom/custom_viewer.html

This example demonstrates creating a custom viewer by subclassing CustomViewer. It defines a class-level variable 'checkbox' and overrides the plot_data method.

```python
class CustomViewerSubset(CustomViewer):
    checkbox = False

    def plot_data(self, checkbox, axes):
        axes.plot([1, 2, 3])
```

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

### Example of a custom session patch function

Source: https://docs.glueviz.org/en/stable/_sources/customizing_guide/customization.rst

Custom patch functions can be provided to edit session files in-place after loading. This example shows the basic structure of such a function.

```python
from glue.config import session_patch

@session_patch(priority=0)
def correct_bad_version_plugin(session_obj):
    # if problem:
        # correct problem

    ...

    return
```
Tokens:
Raw